JavaScript aporta una funcionalidad dinámica a tus sitios web. Cada vez que mires algo aparecer cuando pasas el mouse sobre un elemento en el navegador, o ves nuevo texto, colores o imágenes aparecer en la página frente a tus ojos, o cuando tomas un objeto en la página y lo arrastras a una nueva ubicación, todas esas cosas generalmente se hacen a través de JavaScript (aunque CSS se está volviendo cada vez más poderoso y también puede hacer muchas de estas cosas). Ofrece efectos que de otro modo no serían posibles, porque se ejecuta dentro del navegador y tiene acceso directo a todos los elementos de un documento web.
JavaScript apareció por primera vez en el navegador Netscape Navigator en 1995, coincidiendo con la incorporación del soporte para la tecnología Java en el navegador. Debido a la incorrecta impresión inicial de que JavaScript era un derivado de Java, ha habido una confusión durante mucho tiempo sobre su relación. Sin embargo, el nombre fue solo una táctica de marketing para ayudar al nuevo lenguaje de scripting a beneficiarse de la popularidad del lenguaje de programación Java.
JavaScript ganó nuevo poder cuando los elementos HTML de la página web obtuvieron una definición más formal y estructurada en lo que se llama Document Object Model (DOM). El DOM hace que sea relativamente fácil añadir un nuevo párrafo o centrarse en un fragmento de texto y modificarlo.
Debido a que tanto JavaScript como PHP soportan gran parte de la sintaxis de la programación estructurada que utiliza el lenguaje de programación C, son muy similares entre sí. También son lenguajes de alto nivel. Además, son débilmente tipados, por lo que es fácil cambiar una variable a un nuevo tipo simplemente usándola en un nuevo contexto.
Ahora que has aprendido PHP, deberías encontrar JavaScript aún más fácil. Y te alegrarás de haberlo hecho, porque está en el corazón de la tecnología de la comunicación asíncrona que proporciona las interfaces web fluidas que (junto con las características de HTML5) los usuarios web expertos esperan hoy en día.
JavaScript es un lenguaje de scripting del lado del cliente que se ejecuta completamente dentro del navegador web o bajo Node.js. Para llamarlo, se coloca entre las etiquetas HTML de apertura <script> y cierre </script>. Un documento típico de "Hello World" utilizando JavaScript puede parecerse al Ejemplo 14-1.
Ejemplo 14-1. Visualización de "Hello World" con JavaScript
1
2
3
4
5
6
7
8
9
10
11
12
13
<html>
<head>
<title>Hello World</title>
</head>
<body>
<script type="text/javascript">
document.write("Hello World")
</script>
<noscript>
Your browser doesn't support or has disabled JavaScript
</noscript>
</body>
</html>
Nota
Es posible que hayas visto páginas web que utilizan la etiqueta HTML <script language="javascript">, pero ahora esa manera está obsoleta. Este ejemplo utiliza el más reciente y preferido <script type="text/javascript">, o puedes simplemente utilizar <script> por tu cuenta si lo prefieres.
Dentro de las etiquetas <script> hay una sola línea de código JavaScript que utiliza su equivalente a los comandos echo o print de PHP, es document.write. Como era de esperar, simplemente envía el string proporcionado al documento actual, donde se muestra.
También puede que haya notado que, a diferencia de PHP, no hay punto y coma al final. (;). Esto se debe a que un salto de línea cumple la misma función que un punto y coma en JavaScript. Sin embargo, si deseas tener más de una instrucción en una sola línea, debes colocar un punto y coma después de cada comando, excepto el último. Por supuesto, si lo deseas, puedes añadir un punto y coma al final de cada instrucción, y tu JavaScript funcionará bien. Mi preferencia personal es omitir el punto y coma porque es innecesario, y por lo tanto también evito prácticas que podrían causar problemas. Al final del día, sin embargo, la elección puede depender del equipo en el que trabajes, que más a menudo no puede requerir puntos y coma, solo para estar seguros. Entonces, si tienes dudas, simplemente añade los puntos y comas.
Lo otro a tener en cuenta en este ejemplo es el par de etiquetas <noscript> y </noscript>. Estos se utilizan cuando deseas ofrecer HTML alternativo a los usuarios cuyos navegadores no soportan JavaScript o lo tienen desactivado. El uso de estas etiquetas depende de ti, ya que no son obligatorias, pero realmente deberías usarlas porque generalmente no es tan difícil proporcionar alternativas HTML estáticas a las operaciones que ofreces utilizando JavaScript. Sin embargo, los ejemplos restantes en este libro omitirán las etiquetas <noscript>, porque nos estamos enfocando en lo que puedes hacer con JavaScript, no en lo que puedes hacer sin él.
Cuando se carga el Ejemplo 14-1, un navegador web con JavaScript habilitado mostrará lo siguiente (ver Figura 14-1):
Hello World
Un navegador con JavaScript desactivado mostrará este mensaje (ver Figura 14-2):
Your browser doesn't support or has disabled JavaScript
Además de colocar un script dentro del cuerpo de un documento, puedes ponerlo en la sección <head>, que es el lugar ideal si deseas ejecutar un script cuando se carga una página. Si colocas código y funciones críticas allí, también puedes tener la seguridad de que estén listos para usarse de inmediato por cualquier otra sección de script en el documento que dependa de ellos.
Otra razón para colocar un script en la cabecera del documento es permitir que JavaScript escriba cosas como meta etiquetas en la sección <head>, porque la ubicación de tu script es la parte del documento donde se escribe (imprime) por defecto.
Si necesitas soportar navegadores que no ofrecen scripting (muy poco probable en la actualidad), deberás usar las etiquetas de comentario HTML (<!-- y -->) para evitar que se encuentren con código script que no deberían ver. El ejemplo 14-2 muestra cómo añadirlos a tu código de script.
Ejemplo 14-2. El ejemplo de "Hello World" modificado para navegadores que no soportan JavaScript
1
2
3
4
5
6
7
8
9
10
11
<html>
<head>
<title>Hello World</title>
</head>
<body>
<script type="text/javascript"><!--
document.write('Hello World')
// -->
</script>
</body>
</html>
Aquí se ha añadido una etiqueta HTML de apertura de comentario (<!--) directamente después de la declaración de apertura <script>, y se ha añadido una etiqueta de cierre de comentario (// -->) directamente antes de que el script se cierre con </script>.
La doble barra diagonal (//) la utiliza JavaScript para indicar que el resto de la línea es un comentario. Está ahí para que los navegadores que sí soportan JavaScript ignoren el siguiente -->, pero los navegadores que no soportan JavaScript ignorarán el // anterior y actuarán sobre el --> cerrando el comentario HTML.
Aunque la solución es un poco complicada, lo único que realmente necesitas recordar es utilizar las dos líneas siguientes para encerrar tu JavaScript cuando desees soportar navegadores muy antiguos o no estándar:
1
2
3
4
<script type="text/javascript"><!--
(Your JavaScript goes here...)
// -->
</script>
Sin embargo, el uso de estos comentarios es innecesario para cualquier navegador lanzado en los últimos años, pero debes estar al tanto de esto, por si acaso.
Además de escribir código JavaScript directamente en documentos HTML, puedes incluir archivos de código JavaScript desde tu sitio web o desde cualquier lugar de internet. La sintaxis para esto es la siguiente:
1
<script type="text/javascript" src="script.js"></script>
O, para cargar un archivo desde internet, usa esto (aquí sin el type="text/javascript" ya que es opcional):
1
<script src="http://someserver.com/script.js"></script>
En cuanto a los archivos de script en sí, no deben incluir ninguna etiqueta <script> o </script>, porque son innecesarias: el navegador ya sabe que se está cargando un archivo JavaScript. Ponerlos en los archivos JavaScript causará un error.
Incluir archivos de script es la forma preferida para que uses archivos JavaScript de terceros en tu sitio web.
Nota
Es posible omitir el parámetro type="text/javascript"; todos los navegadores modernos asumen por defecto que el script contiene JavaScript.
Cuando estás aprendiendo JavaScript, es importante poder rastrear errores de escritura u otros errores de codificación. A diferencia de PHP, que muestra mensajes de error en el navegador, JavaScript maneja los mensajes de error de una manera que cambia de acuerdo con el navegador que se está utilizando. La Tabla 14-1 muestra cómo acceder a los mensajes de error de JavaScript en los navegadores más utilizados.
Tabla 14-1. Acceso a los mensajes de error de JavaScript en diferentes navegadores
Navegador | Cómo acceder a los mensajes de error de JavaScript |
---|---|
Apple Safari | Abre Safari y elige Safari > Preferencias > Avanzado. Luego selecciona Mostrar menú de desarrollo en la barra de menú. Elige Desarrollar > Mostrar Consola de Errores |
Google Chrome, Microsoft Edge, Mozilla Firefox, & Opera | Presiona Ctrl + Shift + J en una PC o Command + Shift + J en una Mac. |
Por favor, consulte la documentación de los desarrolladores del navegador en sus sitios web para obtener todos los detalles sobre su uso.
Debido a su herencia compartida del lenguaje de programación C, PHP y JavaScript tienen muchas similitudes, una de las cuales es la forma de comentar. Primero, hay el comentario de una sola línea, como este:
1
// This is a comment
Este estilo utiliza un par de caracteres de barra diagonal (//) para informar a JavaScript que todo lo que sigue debe ser ignorado. También tienes comentarios multilínea, como este:
1
2
3
4
/* This is a section
of multiline comments
that will not be
interpreted */
Empiezas un comentario de varias líneas con la secuencia /* y lo terminas con */. Solo recuerda que no puedes anidar comentarios multilínea, así que asegúrate de no comentar grandes secciones de código que ya contengan comentarios multilínea.
A diferencia de PHP, JavaScript generalmente no requiere punto y coma si tienes solo una instrucción en una línea. Por lo tanto, lo siguiente es válido:
1
x += 10
Sin embargo, cuando desees colocar más de una declaración en una línea, debes separarlas con punto y coma, así:
1
x += 10; y -= 5; z = 0
Normalmente puedes omitir el punto y coma final, porque la nueva línea termina la declaración final.
Precaución
Hay excepciones a la regla del punto y coma. Si escribes bookmarklets (marcadores) en JavaScript, o terminas una declaración con una referencia a una variable o función, y el primer carácter de la siguiente línea es un paréntesis izquierdo o un corchete, debes recordar agregar un punto y coma o JavaScript fallará. Entonces, cuando tengas dudas, usa un punto y coma.
Ningún carácter en particular identifica una variable en JavaScript como lo hace el signo de dólar en PHP. En su lugar, las variables utilizan las siguientes reglas de nomenclatura:
Y sí, tienes razón: hay un $ en esta lista de caracteres permitidos. Está permitido por JavaScript y puede ser el primer carácter de un nombre de una variable o función. Aunque no recomiendo utilizar los caracteres $, esta regla te permite integrar mucho código PHP más rápidamente a JavaScript.
Las variables string en JavaScript deben estar entre comillas simples o dobles, así:
1
2
greeting = "Hello there"
warning = 'Be careful'
Puedes incluir una comilla simple dentro de un string de comillas dobles o una comilla doble dentro de un string de comillas simples. Pero debes escapar el entrecomillado del mismo tipo usando el carácter de barra invertida, así:
1
2
greeting = "\"Hello there\" is a greeting"
warning = '\'Be careful\' is a warning'
Para leer de una variable string, puedes asignarla a otra, así:
1
newstring = oldstring
o puedes usarla en una función, así:
1
2
status = "All systems are working"
document.write(status)
Crear una variable numérica es tan simple como asignarle un valor, como estos ejemplos:
1
2
count = 42
temperature = 98.4
Al igual que los strings, las variables numéricas pueden leerse y usarse en expresiones y funciones.
Los arrays en JavaScript también son muy similares a los de PHP, en el sentido de que un array puede contener datos de tipo string o numéricos, así como otros arrays. Para asignar valores a un array, utiliza la siguiente sintaxis (que en este caso crea un array de strings):
1
toys = ['bat', 'ball', 'whistle', 'puzzle', 'doll']
Para crear un array multidimensional, anida arrays más pequeños dentro de uno más grande. Entonces, para crear un array bidimensional que contenga los colores de una sola cara de un Cubo Rubik desordenado (donde los colores red (rojo), green (verde), orange (naranja), yellow (amarillo), blue (azul) y white (blanco) están representados por sus letras iniciales en mayúscula), podrías usar el siguiente código:
1
2
3
4
5
face = [
['R', 'G', 'Y'],
['W', 'R', 'O'],
['Y', 'W', 'G']
]
El ejemplo anterior se le ha dado formato para que sea obvio lo que está sucediendo, pero también podría escribirse así:
1
face = [['R', 'G', 'Y'], ['W', 'R', 'O'], ['Y', 'W', 'G']]
o incluso así:
1
2
3
4
5
top = ['R', 'G', 'Y']
mid = ['W', 'R', 'O']
bot = ['Y', 'W', 'G']
face = [top, mid, bot]
Para acceder al elemento dos hacia abajo y tres hacia la derecha en este array, usarías lo siguiente (porque los elementos del array comienzan en la posición 0):
1
document.write(face[1][2])
Esta declaración mostrará la letra O para orange (naranja).
Nota
Los arrays en JavaScript son estructuras de almacenamiento poderosas, por lo que el Capítulo 16 se tratan con mucho más detalle.
Los operadores en JavaScript, al igual que en PHP, pueden incluir matemáticas, cambios en strings y operaciones de comparación y lógicas. (and, or, etc.). Los operadores matemáticos de JavaScript se parecen mucho a la aritmética básica; por ejemplo, la siguiente instrucción devuelve 15:
1
document.write(13 + 2)
Las siguientes secciones te enseñan sobre los distintos operadores.
Los operadores aritméticos se utilizan para realizar operaciones matemáticas. Puedes usarlos para las cuatro operaciones principales (suma, resta, multiplicación y división), así como para encontrar el módulo de una división (el residuo después de una división) y para incrementar o decrementar un valor. (ver la Tabla 14-2).
Tabla 14-2. Operadores aritméticos
Operador | Descripción | Ejemplo |
---|---|---|
+ | Suma | j + 12 |
- | Resta | j - 22 |
* | Multiplicación | j * 7 |
/ | División | j / 3.13 |
% | Módulo (resto de la división) | j % 6 |
++ | Incremento | ++j |
-- | Decremento | --j |
Los operadores de asignación se utilizan para asignar valores a las variables. Empiezan con el muy simple = y continúan con +=, –=, y así sucesivamente. El operador += añade el valor del lado derecho a la variable del lado izquierdo, en lugar de reemplazar totalmente el valor del lado izquierdo. Así, si count comienza con el valor de 6, la declaración:
1
count += 1
establece count en 7, al igual que la declaración de asignación más familiar:
1
count = count + 1
La Tabla 14-3 enumera los distintos operadores de asignación disponibles.
Tabla 14-3. Operadores de asignación
Operador | Ejemplo | Equivalente a |
---|---|---|
= | j = 99 | j = 99 |
+= | j += 2 | j = j + 2 |
+= | j += 'string' | j = j + 'string' |
–= | j –= 12 | j = j – 12 |
*= | j *= 2 | j = j * 2 |
/= | j /= 6 | j = j / 6 |
%= | j %= 7 | j = j % 7 |
Los operadores de comparación se utilizan generalmente dentro de una estructura como una declaración if, donde necesitas comparar dos elementos. Por ejemplo, puede que desee saber si una variable que ha estado incrementando ha alcanzado un valor específico, o si otra variable es menor que un valor establecido, y así sucesivamente. (ver la Tabla 14-4).
Tabla 14-4. Operadores de comparación
Operador | Descripción | Ejemplo |
---|---|---|
== | Es igual a | j == 42 |
!= | No es igual a | j != 17 |
> | Es mayor que | j > 0 |
< | Es menor que | j < 100 |
>= | Es mayor o igual que | j >= 23 |
<= | Es menor o igual que | j <= 13 |
=== | Es igual a (y del mismo tipo) | j === 56 |
!== | No es igual a (y del mismo tipo) | j !== '1' |
A diferencia de PHP, los operadores lógicos de JavaScript no incluyen equivalentes de and y or a && y ||, y no hay un operador xor. (ver la Tabla 14-5).
Tabla 14-5. Operadores lógicos
Operador | Descripción | Ejemplo |
---|---|---|
&& | And | j == 1 && k == 2 |
|| | Or | j < 100 || j > 0 |
! | Not | ! (j == k) |
Las siguientes formas de post y preincremento y decremento que aprendiste a utilizar en PHP también son compatibles con JavaScript, al igual que los operadores de asignación abreviada:
1
2
3
4
++x
--y
x += 22
y -= 3
JavaScript maneja la concatenación de strings de manera ligeramente diferente a PHP. En lugar del operador . (punto), utiliza el signo más (+), así:
1
document.write("You have " + messages + " messages.")
Suponiendo que la variable messages está establecida con el valor de 3, la salida de esta línea de código será la siguiente:
You have 3 messages.
Así como puedes agregar un valor a una variable numérica con el operador +=, también puedes concatenar un string a otra de la misma manera:
1
2
name = "James"
name += " Dean"
Los caracteres de escape, que se han utilizado para insertar comillas en los strings, también pueden ser utilizados para insertar varios caracteres especiales, como tabulaciones, saltos de línea y retornos de carro. Aquí hay un ejemplo usando tabulaciones para organizar un encabezado: se incluye aquí simplemente para ilustrar escapes, porque en las páginas web, hay mejores maneras de hacer el diseño:
1
heading = "Name\tAge\tLocation"
La Tabla 14-6 detalla los caracteres de escape disponibles.
Tabla 14-6. Caracteres de escape en JavaScript
Caracter | Significado |
---|---|
\b | Retroceso |
\f | Salto de página |
\n | Salto de línea |
\r | Retorno de carro |
\t | Tabulador |
\' | Comillas simples (o apóstrofe) |
\" | Comillas dobles |
\\ | Barra invertida |
\XXX | Un número octal entre 000 y 377 que representa el equivalente de caracteres Latin-1 (como \251 para el símbolo ©) |
\xXX | Un número hexadecimal entre 00 y FF que representa el equivalente de caracteres Latin-1 (como \xA9 para el símbolo ©) |
\uXXXX | Un número hexadecimal entre 0000 y FFFF que representa el equivalente de caracteres Unicode (como \u00A9 para el símbolo ©) |
Al igual que PHP, JavaScript es un lenguaje muy débilmente tipado; el tipo de dato de una variable se determina solo cuando se le asigna un valor y puede cambiar a medida que la variable aparece en diferentes contextos. Por lo general, no tienes que preocuparte por el tipo de dato de las variables; JavaScript averigua lo que quieres y simplemente lo hace.
Echa un vistazo al Ejemplo 14-3, en el cual:
Ejemplo 14-3. Establece el tipo de dato de una variable por asignación
1
2
3
4
5
6
7
8
9
10
<script>
n = '838102050' // Set 'n' to a string
document.write('n = ' + n + ', and is a ' + typeof n + '<br>')
n = 12345 * 67890; // Set 'n' to a number
document.write('n = ' + n + ', and is a ' + typeof n + '<br>')
n += ' plus some text' // Change 'n' from a number to a string
document.write('n = ' + n + ', and is a ' + typeof n + '<br>')
</script>
La salida de este script se ve así:
n = 838102050, and is a string n = 838102050, and is a number n = 838102050 plus some text, and is a string
Si alguna vez hay alguna duda sobre el tipo de dato de una variable, o necesitas asegurarte de que una variable tenga un tipo de dato en particular, puedes forzarla a ese tipo de dato utilizando declaraciones como las siguientes (que convierten respectivamente un string a un número y un número a un string):
1
2
3
4
5
n = "123"
n *= 1 // Convert 'n' into a number
n = 123
n += "" // Convert 'n' into a string
O puedes usar las siguientes funciones de la misma manera:
1
2
3
4
5
6
n = "123"
n = parseInt(n) // Convert 'n' into an integer number
n = parseFloat(n) // Convert 'n' into a floating point number
n = 123
n = n.toString() // Convert 'n' into a string
Puedes leer más sobre la conversión de tipos de datos en JavaScript en línea (https://es.javascript.info/type-conversions). Y siempre puedes consultar el tipo de dato de una variable usando el operador typeof.
Al igual que con PHP, las funciones en JavaScript se utilizan para separar secciones de código que realizan una tarea específica. Para crear una función, se declara de la manera que se muestra en el Ejemplo 14-4.
Ejemplo 14-4. Una declaración simple de una función
1
2
3
4
5
6
<script>
function product(a, b)
{
return a*b
}
</script>
Esta función toma los dos parámetros pasados, los multiplica y devuelve el resultado.
Las variables globales son aquellas definidas fuera de cualquier función (o definidas dentro de funciones pero sin la palabra clave var). Pueden definirse de las siguientes maneras:
1
2
3
a = 123 // Global scope
var b = 456 // Global scope
if (a == 123) var c = 789 // Global scope
Independientemente si estás utilizando la palabra clave var, mientras una variable esté definida fuera de una función, su alcance es global. Esto significa que cada parte de un script puede tener acceso a él.
Los parámetros pasados a una función automáticamente tienen un alcance local, es decir, solo pueden ser referenciados dentro de esa función. Sin embargo, hay una excepción. Los arrays se pasan a una función por referencia, por lo que si modificas cualquier elemento de un parámetro de tipo array, los elementos del array original serán modificados.
Para definir una variable local que tenga alcance solo dentro de la función actual y que no haya sido pasada como parámetro, utiliza la palabra clave var. El Ejemplo 14-5 muestra una función que crea una variable con alcance global y dos con alcance local.
Ejemplo 14-5. Una función que crea variables con alcance global y local
1
2
3
4
5
6
7
8
<script>
function test()
{
a = 123 // Global scope
var b = 456 // Local scope
if (a == 123) var c = 789 // Local scope
}
</script>
Para comprobar si la configuración del alcance ha funcionado en PHP, podemos usar la función isset. Pero en JavaScript no existe tal función, así que el Ejemplo 14-6 utiliza el operador typeof, que devuelve el string undefined cuando una variable no está definida.
Ejemplo 14-6. Verificación del alcance de las variables definidas en la función test
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<script>
test()
if (typeof a != 'undefined') document.write('a = "' + a + '"<br>')
if (typeof b != 'undefined') document.write('b = "' + b + '"<br>')
if (typeof c != 'undefined') document.write('c = "' + c + '"<br>')
function test()
{
a = 123
var b = 456
if (a == 123) var c = 789
}
</script>
La salida de este script es la siguiente línea:
a = "123"
Esto muestra que solo la variable a recibió un alcance global, que es exactamente lo que esperaríamos, ya que las variables b y c recibieron un alcance local al estar precedidas por la palabra clave var.
Si tu navegador emite una advertencia sobre que b está indefinido, la advertencia es correcta pero se puede ignorar.
JavaScript ahora ofrece dos nuevas palabras clave: let y const. La palabra clave let es prácticamente un reemplazo para var, pero tiene la ventaja de que no puedes redeclarar una variable una vez que lo hayas hecho con let, aunque sí puedes con var.
Verás, el hecho de que pudieras redeclarar variables utilizando var estaba llevando a errores oscuros, como el siguiente:
1
2
3
4
5
6
7
8
9
var hello = "Hello there"
var counter = 1
if (counter > 0)
{
var hello = "How are you?"
}
document.write(hello)
¿Puedes ver el problema? Debido a que counter es mayor que 0 (ya que lo inicializamos en 1), el string hello se redefine como "How are you?" (¿Cómo estás?) y luego se muestra en el documento.
Ahora, si reemplazas var con let (como lo siguiente), la segunda declaración será ignorada, y se mostrará el string original "Hello there":
1
2
3
4
5
6
7
8
9
let hello = "Hello there"
let counter = 1
if (counter > 0)
{
let hello = "How are you?"
}
document.write(hello)
La palabra clave var tiene un alcance global (si está fuera de cualquier bloque o función) o de función, y las variables declaradas se inicializan con undefined, pero la palabra clave let tiene un alcance global o de bloque, y las variables no se inicializan.
Cualquier variable asignada utilizando let tiene un alcance dentro de todo el documento si se declara fuera de cualquier bloque, o, si se declara dentro de un bloque delimitado por {} (lo que incluye funciones), su alcance se limita a ese bloque (y cualquier sub-bloque anidado). Si declaras una variable dentro de un bloque pero intentas acceder a ella desde fuera de ese bloque, se devolverá un error, como en el siguiente caso, que fallará en el document.write porque hello no tendrá valor:
1
2
3
4
5
6
7
8
let counter = 1
if (counter > 0)
{
let hello = "How are you?"
}
document.write(hello)
Puedes usar let para declarar variables con el mismo nombre que las variables previamente declaradas, siempre y cuando sean dentro de un nuevo ámbito, en cuyo caso cualquier valor anterior asignado a una variable con el mismo nombre en el ámbito anterior se volverá inaccesible para el nuevo ámbito, porque la nueva variable con el mismo nombre se maneja totalmente diferente de la anterior. Solo tiene alcance dentro del bloque actual, o de cualquier sub-bloque (a menos que se use otro let para declarar otra variable con el mismo nombre en un sub-bloque).
Es una buena práctica intentar evitar la reutilización de nombres significativos de variables, o corres el riesgo de causar confusión. Sin embargo, las variables de bucle o índice como i (u otros nombres cortos y simples) generalmente pueden reutilizarse en nuevos ámbitos sin causar confusión.
Puedes aumentar aún más tu control sobre el alcance declarando una variable con un valor constante, es decir, uno que no pueda ser cambiado. Esto es beneficioso cuando has creado una variable que lo estás tratando como una constante pero la has declarado utilizando solo var o let, porque podrías tener ocasiones que en tu código intentes cambiar ese valor, lo cual estaría permitido pero sería un error.
Sin embargo, si utilizas la palabra clave const para declarar la variable y asignar su valor, cualquier intento de cambiar más tarde su valor será prohibido, y tu código se detendrá con un mensaje de error en la consola similar a:
Uncaught TypeError: Assignment to constant variable
El siguiente código causará exactamente ese error:
1
2
3
4
5
6
7
8
9
const hello = "Hello there"
let counter = 1
if (counter > 0)
{
hello = "How are you?"
}
document.write(hello)
Al igual que let, las declaraciones const también tienen un alcance de bloque (dentro de secciones {} y cualquier sub-bloque), lo que significa que puedes tener variables constantes con el mismo nombre pero con diferentes valores en diferentes ámbitos de un fragmento de código. Sin embargo, te recomiendo encarecidamente que intentes evitar la duplicación de nombres y mantengas cualquier nombre de constante para un solo valor a lo largo de cada programa, utilizando un nuevo nombre de constante donde necesites una nueva constante.
En resumen: var tiene un alcance global o de función, y let y const tienen un alcance global o de bloque. Tanto var como let pueden ser declarados sin ser inicializados, mientras que const debe ser inicializado durante la declaración. La palabra clave var se puede reutilizar para redeclarar una variable var, pero let y const no pueden. Finalmente, const no puede ser redeclarado ni reasignado.
Nota
Es posible que prefieras utilizar una consola de desarrollador para pruebas como estas (y en otras partes de este libro) como se explicó anteriormente en "Depuración de errores en JavaScript", en cuyo caso puedes reemplazar document.write con console.log, y la salida se mostrará en la consola en lugar del documento del navegador. También es una mejor opción para que JavaScript se ejecute una vez que el documento se haya cargado completamente, porque en ese momento document.write reemplazaría el documento actual, en lugar de agregarle contenido, lo cual probablemente no sea lo que esperes.
El diseño de JavaScript es muy inteligente. En lugar de simplemente crear otro lenguaje de scripting (lo que hubiera sido una mejora bastante buena en ese momento), había una visión de construirlo alrededor del ya existente Document Object Model de HTML. Este modelo descompone las partes de un documento HTML en objetos discretos, cada uno con sus respectivas propiedades y métodos, y cada uno sujeto al control de JavaScript.
JavaScript separa objetos, propiedades y métodos utilizando un punto (una buena razón por la cual + es el operador de concatenación de strings en JavaScript, en lugar del punto). Por ejemplo, consideremos una tarjeta de presentación como un objeto al que llamaremos card. Este objeto contiene propiedades como su nombre, dirección, número de teléfono, y así sucesivamente. En la sintaxis de JavaScript, estas propiedades se verían así:
card.name card.phone card.address
Sus métodos son funciones que recuperan, modifican y actúan de otras maneras sobre las propiedades. Por ejemplo, para invocar un método que muestre las propiedades del objeto card, podrías utilizar una sintaxis como esta:
1
card.display()
Echa un vistazo a algunos de los ejemplos anteriores en este capítulo y observa dónde se utiliza la instrucción document.write. Ahora que entiendes cómo JavaScript se basa en objetos, verás que write es en realidad un método del objeto document.
Dentro de JavaScript, existe una jerarquía de objetos padre e hijo, que es lo que se conoce como el Document Object Model. (DOM; ver Figura 14-3).
La figura utiliza etiquetas HTML con las que ya estás familiarizado para ilustrar la relación padre/hijo entre los distintos objetos de un documento. Por ejemplo, una URL dentro de un enlace es parte del cuerpo de un documento HTML. En JavaScript, se hace referencia a ello así:
1
url = document.links.linkname.href
Observa cómo esto sigue la columna central hacia abajo. La primera parte, document, se refiere a las etiquetas <html> y <body>; links.linkname se refiere a la etiqueta <a>, y href al atributo href.
Vamos a convertir la expresión en HTML y un script para leer las propiedades de un enlace. Escribe el Ejemplo 14-7 y guárdalo como linktest.html; luego ábrelo en tu navegador.
Ejemplo 14-7. Leer una URL de un enlace con JavaScript
1
2
3
4
5
6
7
8
9
10
11
12
<html>
<head>
<title>Link Test</title>
</head>
<body>
<a id="mylink" href="http://mysite.com">Click me</a><br>
<script>
url = document.links.mylink.href
document.write('The URL is ' + url)
</script>
</body>
</html>
Observa la forma corta de las etiquetas <script>, donde he omitido el parámetro type="text/JavaScript" para ahorrarte un poco de escritura. Si lo deseas, solo con el fin de probar esto (y otros ejemplos), también podrías omitir todo lo que esté fuera de las etiquetas <script> y </script>. El resultado de este ejemplo es el siguiente:
Click me
The URL is http://mysite.com
La segunda línea de la salida proviene del método document.write. Observa cómo el código sigue el árbol del documento desde document hasta links, luego a mylink (el id dado al enlace) y finalmente a href (el valor de destino de la URL).
También hay una forma corta que funciona igual de bien, que comienza con el valor en el atributo id: mylink.href. Entonces, puedes reemplazar esto:
1
url = document.links.mylink.href
con lo siguiente:
1
url = mylink.href
Como se mencionó anteriormente, el símbolo $ está permitido en los nombres de variables y funciones de JavaScript. Debido a esto, a veces puedes encontrarte con código de aspecto extraño como este:
1
url = $('mylink').href
Algunos programadores con iniciativa han decidido que la función getElementById es tan importante en JavaScript que han escrito una función para reemplazar la llamada $, como en jQuery (aunque jQuery usa el $ para mucho más que eso ver Capítulo 22), como se muestra en el Ejemplo 14-8.
Ejemplo 14-8. Una función que reemplaza el método getElementById
1
2
3
4
5
6
<script>
function $(id)
{
return document.getElementById(id)
}
</script>
Por lo tanto, siempre y cuando hayas incluido la función $ en tu código, una sintaxis como esta:
1
$('mylink').href
puede reemplazar al siguiente código:
1
document.getElementById('mylink').href
El objeto links es en realidad un array de URLs, por lo que la URL mylink en el Ejemplo 14-7 también puede referirse de manera segura en todos los navegadores de la siguiente manera (porque es el primer y único enlace):
1
url = document.links[0].href
Si quieres saber cuántos enlaces hay en un documento completo, puedes consultar la propiedad length del objeto links así:
1
numlinks = document.links.length
Puedes extraer y mostrar todos los enlaces en un documento de esta manera:
1
2
for (j=0; j < document.links.length; ++j)
document.write(document.links[j].href + '<br>')
El length de algo es una propiedad de cada array, y de muchos objetos también. Por ejemplo, el número de elementos en el historial web de tu navegador se puede consultar así:
1
document.write(history.length)
Para evitar que los sitios web espíen tu historial de navegación, el objeto history almacena solo el número de sitios en el array: no puedes leer ni escribir en estos valores. Pero puedes reemplazar la página actual con una del historial, si sabes en qué posición se encuentra dentro del historial. Esto puede ser muy útil en casos en los que sabes que ciertas páginas en el historial provienen de tu sitio, o simplemente desees que el navegador retroceda una o más páginas, lo cual puedes hacer con el método go del objeto history. Por ejemplo, para hacer que el navegador retroceda tres páginas, emita el siguiente comando:
1
history.go(-3)
También puedes utilizar los siguientes métodos para avanzar o retroceder una página a la vez:
1
2
history.back()
history.forward()
De manera similar, puedes reemplazar la URL actualmente cargada con una de tu elección, así:
1
document.location.href = 'http://google.com'
Por supuesto, hay mucho más cosas en el DOM que leer y modificar enlaces. A medida que avances a través de los siguientes capítulos sobre JavaScript, te familiarizarás bastante con el DOM y cómo acceder a él.
Al enseñar programación, es necesario tener una forma rápida y fácil de mostrar los resultados de las expresiones. En PHP (por ejemplo) existen las declaraciones echo y print, que simplemente envían texto al navegador, así que es fácil. En JavaScript, sin embargo, existen las siguientes alternativas.
La función console.log mostrará en la consola del navegador actual el resultado de cualquier valor o expresión que se le pase. Se trata de un modo especial de presentación, con un marco o ventana separada de la ventana del navegador, en la cual se pueden mostrar errores y otros mensajes. Aunque es genial para programadores experimentados, no es la mejor opción para principiantes porque la salida no se parece al contenido web en el navegador.
La función alert muestra en una ventana emergente valores o expresiones que se le pasan, la cual requiere que hagas clic en un botón para cerrarla. Claramente, esto puede volverse bastante irritante muy rápidamente, y tiene la desventaja de mostrar solo el mensaje actual, borrando los anteriores.
Es posible escribir directamente en el texto de un elemento HTML, lo cual es una solución bastante elegante (y la mejor para sitios web en producción), excepto que para este libro cada ejemplo requeriría que se creara dicho elemento y algunas líneas de código JavaScript para acceder a él. Esto interfiere con la enseñanza principal de un ejemplo y haría que el código pareciera excesivamente engorroso y confuso.
La función document.write escribe un valor o expresión en la ubicación actual del navegador y, por lo tanto, es la opción perfecta para mostrar resultados rápidamente. Mantiene todos los ejemplos breves y concisos, colocando la salida justo allí en el navegador junto al contenido web y el código.
Sin embargo, es posible que hayas escuchado que esta función es considerada insegura por algunos desarrolladores, porque cuando la llamas después de que una página web se ha cargado completamente, sobrescribirá el documento actual. Aunque esto es correcto, no se aplica a ninguno de los ejemplos de este libro, porque todos ellos utilizan document.write de la manera en que originalmente se pretendía: como parte del proceso de creación de la página, llamándolo solo antes de que la página haya terminado de cargarse y mostrarse.
No obstante, aunque uso document.write de esta manera para ejemplos simples, nunca lo utilizo en código de producción (excepto en las circunstancias más raras en las que realmente es necesario). En su lugar, casi siempre utilizo la opción anterior de escribir directamente en un elemento especialmente preparado, como en los ejemplos más complejos a partir del Capítulo 18. (que acceden a la propiedad innerHTML de los elementos para presentar la salida del programa).
Así que, por favor, recuerda que cuando veas que se llama a document.write en este libro, está ahí solo para simplificar un ejemplo, y les recomiendo que también usen la función de la misma manera para obtener resultados rápidos de prueba.
Con la advertencia explicada, en el siguiente capítulo continuaremos nuestra exploración con JavaScript analizando cómo controlar el flujo del programa y escribir expresiones.
Ver "Respuestas del capítulo 14" del Apéndice A para comprobar las respuestas a estas preguntas.
1
2
document.write(document.getElementById('thislink').href)
document.write(thislink.href)
1
2
history.back()
history.go(-1)
1
document.location.href = 'http://www.oreilly.com'