Introducción a la ISC

JAVASCRIPT
Contenido
1 UNIDAD I ..................................................................................................................................... 3
1.1 ¿Qué es JavaScript? ............................................................................................................. 4
1.1.1 Definición General ....................................................................................................... 4
1.2 Versiones de JavaScript ....................................................................................................... 4
1.3 Formas de incluir el código JavaScript ................................................................................ 5
1.3.1 JavaScript "en la página" ............................................................................................. 5
1.3.2 JavaScript externo ....................................................................................................... 6
1.3.3 Posición del elemento <script> ................................................................................... 6
1.4 ¿Qué es un script? ............................................................................................................... 6
1.5 Las sentencias...................................................................................................................... 7
1.5.1 Sentencias y declaraciones por categoría ................................................................... 7
1.5.2 Declaraciones .............................................................................................................. 8
1.5.3 Funciones..................................................................................................................... 8
1.5.4 Iteraciones ................................................................................................................... 8
1.5.5 Otros ............................................................................................................................ 9
1.6 Palabras reservadas........................................................................................................... 10
1.6.1 Reserved keywords as of ECMAScript 6 ................................................................. 10
1.6.2 Futuras Palabras Reservadas en estandares antiguos .............................................. 11
1.7 Comentarios ...................................................................................................................... 11
1.7.1 Comentarios de fin de línea. ..................................................................................... 11
1.7.2 Comentarios multilínea. ............................................................................................ 12
1.8 Hola Mundo ....................................................................................................................... 13
2 UNIDAD II .................................................................................................................................. 13
2.1 Las variables. ..................................................................................................................... 14
2.1.1 Tipos de variables ...................................................................................................... 15
2.2 Tipos .................................................................................................................................. 16
2.2.1 number ...................................................................................................................... 16
2.2.2 boolean...................................................................................................................... 16
2.2.3 string.......................................................................................................................... 16
2.2.4 undefined .................................................................................................................. 17
2.3 El alcance de las variables ................................................................................................. 17
2.4 Operadores........................................................................................................................ 17
 2.4.1 Operadores aritméticos ............................................................................................ 17
2.4.2 Incremento o decremento: ....................................................................................... 18
2.4.3 Asignación ................................................................................................................. 19
2.4.4 Operador typeof ........................................................................................................ 19
2.4.5 Operadores booleanos .............................................................................................. 19
2.4.6 Identidad o Igualdad ................................................................................................. 20
2.4.7 Comparación ............................................................................................................. 21
2.4.8 Operadores lógicos.................................................................................................... 22
3 UNIDAD III ................................................................................................................................. 23
3.1 Condicionales .................................................................................................................... 24
3.1.1 Asignación condicional .............................................................................................. 25
3.1.2 Sentencia IF ............................................................................................................... 25
3.1.3 Sentencia Switch ....................................................................................................... 26
3.2 Bucles ................................................................................................................................ 27
3.2.1 Bucle while ................................................................................................................ 27
3.2.2 Bucle Do/While ......................................................................................................... 27
3.2.3 Bucle For .................................................................................................................... 28
4 UNIDAD IV ................................................................................................................................. 29
4.1 Function............................................................................................................................. 30
4.2 Parámetros por defecto .................................................................................................... 30
4.3 Ámbito de una función. ..................................................................................................... 31
5 UNIDAD V .................................................................................................................................. 32
5.1 Number ............................................................................................................................. 33
5.1.1 Funciones de Number ............................................................................................... 33
5.2 Módulo Math .................................................................................................................... 35
5.3 Array .................................................................................................................................. 35
5.4 Object ................................................................................................................................ 36
5.4.1 Anidación ................................................................................................................... 37
5.4.2 Igualdad entre objetos .............................................................................................. 38
1 UNIDAD I

Introducción a JavaScript
1.1 ¿Qué es JavaScript?
JavaScript es un lenguaje de los denominados lenguajes de scripting. Los scripts (script se traduce
como guion, literalmente) son archivos de órdenes, programas por lo general simples. Es por esto
que no podemos definir JavaScript como un lenguaje de programación en un sentido estricto, pero
sin embargo sí nos permite crear páginas dinámicas, con algunos efectos realmente interesantes y
que mejoren considerablemente su aspecto. Nos permite tener cierta interacción con el usuario
de nuestras páginas, reconocer determinados eventos que se puedan producir y responder a éstos
adecuadamente.

Tratándose de un lenguaje de script, los programas que realicemos, no necesitarán ser compilado.
Los lenguajes de scripting son lenguajes interpretados. Esto en la práctica significa que cuando
trabajemos con JavaScript escribiremos nuestro programa y podremos ejecutarlo de forma
directa, sin necesidad de hacer nada más.

1.1.1 Definición General

JavaScript es un lenguaje de programación que te permite realizar actividades complejas en una
página web — cada vez más una página web hace más cosas que sólo mostrar información
estática — como mostrar actualizaciones de contenido en el momento, interactuar con mapas,
animaciones gráficas 2D/3D etc. — puedes estar seguro que JavaScript está involucrado. Es la
tercera capa del pastel de los estándares en las tecnologías para la web, dos de las cuales son
(HTML y CSS).

• HTML es un lenguaje de marcado que usa la estructura

para dar un sentido al contenido web, por ejemplo, define
párrafos, cabeceras, tablas, imágenes y vídeos en la página.
• CSS es un lenguaje de reglas en cascada que usamos para
aplicar un estilo a nuestro contenido en HTML, por ejemplo,
colocando colores de fondo, fuentes y marginando nuestro
contenido en múltiples columnas.
• JavaScript Es un lenguaje de programación que te permite
crear contenido nuevo y dinámico, controlar archivos de
multimedia, crear imágenes animadas y muchas otras cosas
más. (Aunque, no todo, pero es increíble lo que puedes llegar a hacer con tan sólo unas
pocas líneas de código de JavaScript).

1.2 Versiones de JavaScript

Las versiones de JavaScript se basan en los de la ECMAScript (que abreviaremos como ES).
Por lo tanto, se encuentran:
ES 1 y ES 1, que son los inicios de JavaScript.
ES 3 (publicada en diciembre de 1999), que es funcional en todos los navegadores
(excepto las versiones anteriores de Internet Explorer).
ES 4 que fue abandonada debido a los grandes cambios que no fueron apreciados.
ES 5 (publicada en diciembre de 2009).
ES 6 es la versión más reciente liberada (2015).
1.3 Formas de incluir el código JavaScript

1.3.1 JavaScript "en la página"

Para situar el código JavaScript directamente en una página web, nada más simple, siguiendo el
ejemplo de ¡Hola, mundo!, se coloca el código en el elemento <script>:

Código: HTML

<!DOCTYPE html>
<html>
<head>
<title>Ejemplo de código JavaScript en el propio documento</title>
<script type=”text/javascript”>
alert(“Esto es mensaje de prueba”);
</script>
</head>
<body>
<p>Y esto un párrafo de texto.</p>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<title> Ejemplo de código JavaScript en el propio documento </title>
</head>
<body>
<script>
alert('¡Hola Mundo!');
</script>
</body>
</html>
1.3.2 JavaScript externo
Es posible, y conveniente escribir el código JavaScript en un archivo externo con la extensión.
Js. Este archivo se llama desde la página web mediante el elemento <script> y su atributo src
que contiene la dirección URL del archivo. js.

Código: JavaScript - contenido de archivo hola.js

alert ('¡Hola mundo!');

Código: HTML - Página Web

<! DOCTYPE html>

<html>
<head>
<title>¡Hola mundo!!</title>
</head>
<body>
<script src="hola.js"></script>
</body>
</html>

1.3.3 Posición del elemento <script>

La mayoría de los cursos de Javascript, y ejemplos, muestran la necesidad de colocar el
elemento <script> dentro de <head> cuando se utiliza para cargar un archivo javascript. Eso es
correcto, sí, pero hay mejoras.
Una página web es leída por el navegador de forma lineal, es decir, en primer lugar lee <head>,
después los elementos de <body> uno después del otro. Si se llama a un archivo JavaScript
desde el principio de la carga de la página, el navegador por lo tanto cargará este archivo, y si
es grande, la carga de la página se desacelerará. Esto es normal, ya que el navegador cargará
el archivo antes de empezar a mostrar el contenido de la página.
Para superar este problema, es conveniente colocar los elementos <script> justo antes de
cerrar <body>

1.4 ¿Qué es un script?

Una de las peculiaridades que tienen es que se guardan en archivos de tipo texto.

podemos distinguir dos tipos: aquellos que se interpretan del lado del servidor (como es el caso
del PHP) y aquellos que lo son del lado del cliente, como es JavaScript. Para identificar este
segundo tipo, los scripts se preceden de la etiqueta <script>.
Sin embargo, los scripts no son exclusivos de los lenguajes para web, ni siquiera son especialmente
novedosos, ya en el entorno DOS existían los denominados archivos por lotes o batch. Windows
reconoce, además de JavaScript, otros lenguajes de scripts.

1.5 Las sentencias

Las aplicaciones JavaScript se componen de sentencias con una sintaxis propia. Una sentencia
puede estar formada por múltiples líneas. Puede haber varias sentencias en una sola línea si
separamos cada una de las sentencias por un punto y coma. No es una palabra clave, sino un
grupo de palabras clave.

1.5.1 Sentencias y declaraciones por categoría

Control de flujo

Block

Un bloque de sentencias se utiliza para agrupar cero o mas sentencias. El bloque se delimita por
un par de llaves.

break

Finaliza la sentencia actual loop, switch, o label y transfiere el control del programa a la siguiente
sentencia de la sentencia finalizada.

continue

Finaliza la ejecucion de las sentencias dentro de la iteracion actual del actual bucle, y continua la
ejecucion del bucle con la siguiente iteracion.

Empty

Una sentencia vacía se utiliza para proveer una "no sentencia", aunque la sintaxis de JavaScript
esperaba una.

if...else

Ejecuta una sentencia si una condición especificada es true. Si la condición es false, otra sentencia
puede ser ejecutada.

switch

Evalua una expresión, igualando el valor de la expresión a una clausula case y ejecuta las
sentencias asociadas con dicho case.

throw

Lanza una excepción definida por el usuario.

try...catch

Marca un bloque de sentencias para ser probadas (try) y especifica una respuesta, en caso de que
se lance una excepción.
1.5.2 Declaraciones

var Declara una variable, opcionalmente inicializándola a un valor.

let Declara una variable local de ambito de bloque, opcionalmente inicializándola a un valor.

const Declara una constante de solo lectura.

1.5.3 Funciones

function

Declara una función con los parámetros especificados.

function*
Los generadores de funciones permiten escribir iteradores con mas facilidad.

async function

Declara una función asíncrona con los parámetros especificados.

return
Especifica el valor a ser retornado por una función.

class
Declara una clase.

1.5.4 Iteraciones

do...while

Crea un bucle que ejecuta una instrucción especificada hasta que la condición de prueba se
evalúa como falsa. La condición se evalúa después de ejecutar la instrucción, lo que da
como resultado que la instrucción especificada se ejecute al menos una vez.

for
Creates a loop that consists of three optional expressions, enclosed in parentheses and
separated by semicolons, followed by a statement executed in the loop.

for each...in
 Itera una variable especificada sobre todos los valores de las propiedades del objeto. Para
cada propiedad distinta, se ejecuta una instrucción especificada.

for...in
Itera sobre las propiedades enumerables de un objeto, en orden albitrario. Para cada
propiedad distinta, las instrucciones pueden ser ejecutadas.

for...of
Iterates over iterable objects (including array, array-like objects, iterators and generators),
invoking a custom iteration hook with statements to be executed for the value of each
distinct property.
while

Crea un bucle que ejecuta la instrucción especificada siempre que la condición de prueba se
evalúe como verdadera. La condición se evalúa antes de ejecutar la instrucción.

1.5.5 Otros

debugger

Invoca cualquier funcionalidad de depuración disponible. Si no hay funcionalidad de

depuración disponible, esta isntrucción no tiene efecto.

export
Usada para permitir a un script firmada proveer propiedades, funciones y objetos a otros
scripts firmada o sin firmar. Esta antigua funcionalidad de Netscape ha sido removida y será
redefinida por los modulos de ECMAScript 6

import
Usada para permitir a un escript importar propiedades, funciones y objetos desde otro
script firmado que ha exportado su información. Esta antigua funcionalidad de Netscape ha
sido removida y será redefinida por los modulos de ECMAScript 6.

label
Provee una instrucción con un identificador que puedes referir usando una
instrucción break o continue .

with

Extiende la cadena de alcance para una instrucción.

 1.6 Palabras reservadas
Las siguientes son palabras reservadas y no pueden ser utilizadas como variables,
funciones, métodos o identificadores de objetos. Las siguientes son reservadas
como palabras claves existentes por la especificación ECMAScript:

1.6.1 Reserved keywords as of ECMAScript 6

• break
• case
• class
• catch
• const
• continue
• debugger
• default
• delete
• do
• else
• export
• extends
• finally
• for
• function
• if
• import
• in
• instanceof
• let
• new
• return
• super
• switch
• this
• throw
• try
• typeof
• var
• void
• while
• with
• yield

Las siguientes estan reservadas como palabras futuras por la especificación ECMAScript:

• enum
•
 Las siguientes estan reservadas como palabras futuras cuando se encuentre el modo correcto para
su estructura de codigo:

• implements
• package
• protected
• static
• interface
• private
• public

1.6.2 Futuras Palabras Reservadas en estandares antiguos

Las siguientes estan reservadas como palabras futuras por la antigua especificación ECMAScript
(ECMAScript 1 hasta 3).

• abstract
• boolean
• byte
• char
• double
• final
• float
• goto
• int
• long
• native
• short
• synchronized
• transient
• volatile
Adicionalmente, los literales "null", "true", y "false" estan reservadas en ECMAScript para usos
normales.

1.7 Comentarios
Los comentarios son anotaciones realizadas por el desarrollador para explicar el funcionamiento
de un script, una instrucción o incluso un grupo de instrucciones. Los comentarios no interfieren
con la ejecución de un script.

Hay dos tipos de comentarios: los de fin de línea y los multilínea.

1.7.1 Comentarios de fin de línea.

Se utilizan para comentar una instrucción. Comienza con dos barras de división.

Código: JavaScript
sentencia_1 / / Esta es mi primera instrucción
sentencia_2;
/ / La tercera declaración es la siguiente:
sentencia_3;

El texto colocado en un comentario se ignora cuándo se ejecuta un script, lo que significa que
puedes poner un comentario, incluso en una instrucción (que, obviamente, no se ejecutará).

Código: JavaScript

sentencia_1 / / Esta es mi primera instrucción

sentencia_2;
/ / La tercera declaración da problemas, la cancelo temporalmente
/ / sentencia_3;

1.7.2 Comentarios multilínea.

Este tipo permite saltos de línea. Un comentario multilínea comienza con / * y termina con * /.

Código: JavaScript
/ * Este script consta de tres pasos:
- Instrucción uno está haciendo algo
- Instrucción dos para otra cosa
- Instrucción tres que pone fin a la secuencia de comandos
*/
sentencia_1;
sentencia_2;
sentencia_3 / / Fin del script

Ten en cuenta que un comentario de varias líneas se puede mostrar en una sola línea.
Código: JavaScript

sentencia_1 / * Esta es mi primera instrucción * /

sentencia_2;
1.8 Hola Mundo

2 UNIDAD II

Elementos de Programación
Básica
2.1 Las variables.
En programación entendemos por variable un espacio que se reservará en memoria y que será
utilizado para guardar un dato. El valor de ese dato puede variar a lo largo de la ejecución de
nuestro programa, puede ser que necesitemos realizar con él distintas operaciones. Es similar al
concepto matemático de variable, aunque si bien algunas de las operaciones que podemos realizar
con una variable de programación serían matemáticamente inadmisibles. En contraposición, un
valor que no cambia a lo largo de la ejecución de nuestro programa, lo llamaremos constante. En
JavaScript no hay una manera especial de declararlas respecto a las variables, e igualmente se
reserva espacio para ellas.

Como decíamos, una variable es un espacio reservado para guardar un valor, y a ese espacio le
asignamos un nombre.
Se trata de una cuestión práctica, pues siempre resultará más fácil recordar el nombre
precioVenta que la dirección de memoria 34D0 en hexadecimal (y no digamos ya
0011010011010000 en binario). La cosa se complica además si tenemos en cuenta que es
frecuente que un mismo programa utilice cientos de variables.

Nosotros mismos podemos elegir qué nombres dar a nuestras variables. Sin embargo, es
aconsejable que usemos nombres significativos, que nos hagan intuir con facilidad qué datos
guardamos en ella. Por ejemplo, será mucho más fácil entender a primera vista qué contiene la
variable iva8, que la variable llamada solamente con la letra a. El nombre de una variable se puede
llamar también identificador.

En cuanto a restricciones al nombre que elijamos debemos tener en cuenta que JavaScript impone
las siguientes:

• Pueden contener tanto letras como números. Es decir, caracteres alfanuméricos.

• Pero siempre el primer carácter deberá ser una letra o un guion bajo.
• No se admiten espacios en blanco ni otros símbolos como pueden ser: $ % + () / -, etc. Sí,
como hemos dicho en el punto anterior, se admite el guion bajo.

Se ha establecido el convencionalismo de utilizar minúsculas en los nombres de variables, excepto

en el caso de que se componga de dos palabras, en cuyo caso la primera letra de la segunda
palabra se suele escribir en mayúsculas la primera letra. Aunque esto no es estrictamente
necesario cumplirlo.

• No llevan tildes.
• No podemos usar las palabras reservadas para nombrar una variable.

Siguiendo estas normas, serían válidos los siguientes nombres de variables:

2.1.1 Tipos de variables

JavaScript es un lenguaje débilmente tipado. Esto quiere decir que no indicamos de qué tipo es
cada variable que declaramos. Todas las variables admiten todos los tipos, y pueden ser reescritas.
Es una de las cosas buenas y malas que tiene JavaScript.

Definición

Las variables son espacios de memoria donde almacenamos temporalmente datos desde los que
podemos acceder en cualquier momento de la ejecución de nuestros programas. Tienen varios
tipos y clases.

Para definir una variable en JavaScript, utilizamos la palabra reservada var y le damos un nombre,
por ejemplo:
También le podemos asignar un valor en la misma línea que la declaramos, por ejemplo, a
continuación, a la variable dato le asignamos el valor 5.

O podemos primero declarar la variable y más adelante, en otra línea, asignarle un valor.

2.2 Tipos
JavaScript tiene 4 tipos primitivos de datos para almacenar en variables. Estos son:

• number
• boolean
• string
• undefined

2.2.1 number
Sirve para almacenar valores numéricos. Son utilizados para contar, hacer cálculos y
comparaciones. Estos son algunos ejemplos.

2.2.2 boolean
Este tipo de dato almacena un bit que indica true o false. Los valores booleanos se utilizan para
indicar estados. Por ejemplo, asignamos a una variable el estado false al inicio de una operación, y
al finalizarla lo cambiamos a true. Después realizamos la comprobación necesaria.

2.2.3 string
Las variables de tipo string almacenan caracteres o palabras. Se delimitan entre comillas simples o
dobles. Ejemplo:
2.2.4 undefined
Este tipo se utiliza cuando el valor de una variable no ha sido definido aún o no existe.

Por ejemplo:

Otro tipo de almacenamiento de datos que tiene JavaScript son los Objetos. En JavaScript todo es
un objeto, hasta las funciones. Todo hereda de la clase Object. Se pueden definir como una
estructura donde se agregan valores. Dentro de las clases que heredan de Object tenemos Array ,
Date , etc...

2.3 El alcance de las variables

Por alcance o ámbito de una variable entendemos los lugares en los que dicha variable estará
disponible, es decir en los que será “visible” y su valor será accesible. Según este criterio las
variables pueden ser:

Globales: Cuando una variable es declarada en una página, será legible para toda esa página, pero
no para otras.

Locales: Son variables declaradas en ámbitos más pequeños, como por ejemplo una función (que
más adelante veremos). El contenido o valor de esta variable sólo es accesible dentro de ese
pequeño entorno en el cual fue declarada.

Más adelante, cuando veamos las funciones creadas por el programador veremos cómo influye el
lugar y el modo en que se declara una variable en cómo es considerada, si local o global.

2.4 Operadores
2.4.1 Operadores aritméticos
JavaScript posee operadores para tipos y objetos. Estos operadores permiten formar expresiones.
Las más comunes son las operaciones aritméticas.
Son muy sencillos y los habituales en los lenguajes de programación y en operaciones normales.
Quizás el menos habituales el resto de la división entera, se trata de eso literalmente. En el
ejemplo puesto, si hacemos la división sin decimales, en el resto nos aparecería 2, pues a ese 2 es
al que se refiere el resultado.

2.4.2 Incremento o decremento:

Como vemos suma o resta una unidad al valor. Suele ser frecuente su uso en contadores que
deban incrementarse o decrementarse en una unidad. Tienen una peculiaridad que vamos a
explicar con un ejemplo:

Comenzamos dando valor 1 a la variable a. La variable b toma el mismo valor de a, pero

incrementado en una unidad.

Es decir, la variable b valdrá 2. La operación de incrementar en uno se lleva a cabo antes que la
operación de la asignación.

Veamos ahora otro ejemplo:

Al igual que antes la variable a vale 1. La variable b, sin embargo, vale también 1. La razón es que
el incremento es posterior a la asignación. Es decir, a b se le asigna primero el valor de a y
posteriormente el valor de a se incrementa en una unidad.
De igual forma funciona el operador de decremento, según lo coloquemos antes o después del
valor.

2.4.3 Asignación
Además del que habitualmente tienen todos los lenguajes de asignación, es decir el igual (a=7, por
ejemplo), JavaScript permite combinarlo con otros operadores aritméticos de las formas
siguientes:

2.4.4 Operador typeof

El operador typeof es un operador especial que nos permite conocer el tipo que tiene la variable
sobre la que operamos. Ejemplos:

Esto es muy útil para conocer en un momento dado que tipo estamos utilizando y prevenir errores
en el desarrollo.

2.4.5 Operadores booleanos

Los tipos booleanos sólo tienen dos valores posibles: true y false (Verdadero y Falso). Pero
disponen de varios operadores que nos permiten transformar su valor.

Negación Este operador convierte un valor booleando en su opuesto. Se representa con el signo ! .
Si se utiliza dos veces, nos devuelve el valor original.
2.4.6 Identidad o Igualdad
El operador de igualdad (o igualdad débil), se representa con == y el de identidad (o igualdad
estricta), con ===. Se recomienda el uso del operador de identidad (los 3 iguales) frente al de
igualdad débil, ya que el coste de procesamiento de éste último es mucho mayor y sus resultados
en ocasiones son impredecibles. Es una de las partes malas de JavaScript, pero si se tiene cuidado
no tiene por qué darnos ningún problema.

La desigualdad estricta se representa con !== .

Comparación no estricta o con conversión de tipo

La comparación con == o con != es denominada como «comparación no estricta», ya que realiza

conversiones de tipo. Si los dos datos que estamos comparando no son del mismo tipo, se realizan
una serie de conversiones de tipo a fin de encontrar una coincidencia con alguna de las
combinaciones que internamente evalúa.

El problema es que estas conversiones no son siempre muy evidentes y nos pueden desconcertar.
Por ejemplo, las siguientes expresiones son todas verdaderas, aunque pueda parecer que no
debería ser así:

Seguramente algo como 1 == true podemos aceptarlo, ya que ambos son valores que se suelen
denominar como truthy (que se consideran como vedaderas), y las usamos muy habitualmente,
por ejemplo, dentro de instrucciones if (). Aunque no nos estemos dando cuenta, cuando
consideramos que 1 es verdadero y 0 es falso en un if (), estamos aprovechando una conversión
implícita de tipo.
Seguramente nos sintamos más confundidos a la hora de comparar cadenas y números, ya que 1
== "1" no parece que deba ser verdadero, pero esta conversión de tipos es más o menos
previsible.

Lo que es muy difícil de comprender es que algo como [[]] sea igual a 0 o ',,,' sea igual que new
Array(4). Estos caprichos de la conversión de tipos en Javascript ha dado problemas graves en más
de un programa en producción.

En muchos casos los analizadores de código dan un aviso o un error cuando encuentran un ==
advirtiendo que quizás hemos querido poner === y por un descuido nos hemos saltado un signo de
igual. Pero en ocasiones utilizar la conversión de tipo puede ser útil y es algo conveniente, pero es
cierto que un pequeño descuido puede hacer cambiar sustancialmente el comportamiento de
nuestro programa.

Comparación estricta o sin conversión de tipos

En general se considera que la comparación estricta con === o !== es más conveniente y segura.
Este tipo de comparación no realiza ningún tipo de conversión de tipo y nos asegura que coinciden
tanto el valor como el tipo de los dos elementos que estamos comparando. Si que comparamos
datos de tipos diferentes, siempre se producirá un resultado negativo. En ocasiones se dice que
este tipo de comparaciones comprueba tipo y valor, aunque realmente lo que hace es no realizar
ningún tipo de conversión.

2.4.7 Comparación
Podemos comparar si dos valores son menores, mayores o iguales con los operadores de
comparación representados por los símbolos < , > , <= y >= . El resultado de la comparación nos
devuelve true o false dependiendo de si es correcto o no.

Aunque se pueden utilizar comparaciones entre booleanos, strings y objetos se recomienda no

usarlos ya que el orden que siguen no es muy intuitivo.
2.4.8 Operadores lógicos
2.4.8.1 Operador AND
Es un operador lógico que devuelve true siempre que todos los valores comparados sean true. Si
uno de ellos es false, devuelve false. Se representa con el símbolo &&. Veamos un ejemplo.

Es muy utilizado para devolver valores sin que estos sean modificados, por ejemplo, para
comprobar si una propiedad existe, etc. La lógica que sigue es: Si el primer valor es false devuelve
ese valor, si no, devuelve el segundo:

En el ejemplo comparamos 0 y true, como 0 es un valor que retorna false, nos devuelve ese valor.
En el segundo ejemplo 1 es un valor que retorna true, por lo que nos devolverá el segundo "Hola".

Valores que devuelven false.

Hay ciertos valores en JavaScript que son evaluados como false y son: el número 0, un string vacío
"", el valor null, el valor undefined y NaN.
“NaN” es el acrónimo para “Not a Number” y obtenemos este error cuando estamos tratando de
hacer un cast hacia Number de un tipo de dato que no es numérico, por lo que se lanza la
excepción “NaN”.

2.4.8.2 Operador OR
Es otro operador lógico que funciona a la inversa que AND. Devuelve false si los valores
comparados son false. En el caso de que un valor sea true devolverá true. Se representa con el
símbolo ||.

También es muy utilizado para asignar valores por defecto en nuestras funciones. La lógica que
sigue es: Si el primer valor es true, devuelve ese valor. Por ejemplo:

En este ejemplo, la variable port contendrá el valor de process.env.PORT siempre que esa variable
esté definida, si no su valor será 5000.

3 UNIDAD III
 Estructuras de Control

3.1 Condicionales
Los condicionales son expresiones que nos permiten ejecutar una secuencia de instrucciones u
otra diferente dependiendo de lo que estemos comprobando. Permiten establecer el flujo de
ejecución de los programas de acuerdo a determinados estados.
3.1.1 Asignación condicional
Este tipo de asignación es también conocido como el If simplificado u operador ternario. un tipo
de condicional que veremos más adelante. Sirve para asignar en una sola línea un valor
determinado si la condición que se evalúa es true u otro si es false. La sintaxis es la siguiente:

Si la condición devuelve true, retornará el valor de valor_si_true, y si es false el valor devuelto

será el de valor_si_false. Veamos unos ejemplos:

3.1.2 Sentencia IF
Como hemos visto antes, dependiendo del resultado de una condición, obtenemos un valor u
otro. Si el resultado de la condición requiere más pasos, en lugar de utilizar la asignación
condicional, es mejor emplear la sentencia if. Tenemos 3 formas de aplicarlo:

3.1.2.1 if simple

Si se cumple la condición dentro del paréntesis, se ejecuta el bloque de código incluido entre las
llaves { ... }.

3.1.2.2 if/else

Con este tipo de sentencia, si se cumple la condición pasa como el anterior modelo, se ejecuta el
bloque de código 1, y si la condición a evaluar no se cumple, se ejecuta el bloque de código 2.
3.1.2.3 if/else if
Y por último si queremos realizar varias comprobaciones, podemos concatenar varias sentencias
if, else if, etc.. y se irán comprobando en orden:

En el ejemplo anterior, se comprueba la condición 1, si se cumple se ejecuta el bloque 1 y si no, se

comprueba si cumple la condición 2 y en ese caso se ejecutaría el bloque 2, y así sucesivamente
hasta que encuentre una condición que se cumpla o se ejecute el bloque 4 del último else.

3.1.3 Sentencia Switch

Con Switch, podemos sustituir un conjunto de sentencias if-else de una manera más legible. Se
comprueba la condición, y según el caso que devuelva, ejecutará un bloque u otro. Para poder
separar los bloques, se utiliza la palabra break que permite salir de toda la sentencia. Tiene un
bloque default que se ejecuta en el caso de que no se cumpla ningún caso. Veamos un ejemplo,
esto sería un switch siguiendo el ejemplo anterior del if-else:

El bloque default no es obligatorio.

3.2 Bucles
En ocasiones nos interesa que determinados bloques de código se ejecuten varias veces mientras
se cumpla una condición. En ese caso tenemos los bucles para ayudarnos. Dependiendo de lo que
necesitemos usaremos uno u otro.

Existen 3 elementos que controlan el flujo del bucle. La inicialización que fija los valores con los
que iniciamos el bucle. La condición de permanencia en el bucle y la actualización de las variables
de control al ejecutarse la iteración.

3.2.1 Bucle while

La sintaxis de un bucle while es la siguiente, el bloque de código dentro del while se ejecutará
mientras se cumpla la condición.

Si queremos mostrar por consola los números del 1 al 10, con un bucle while sería así.

3.2.2 Bucle Do/While

El bucle do-while es similar al while con la salvedad de que ejecutamos un bloque de código
dentro de do por primera vez y después se comprueba la condición de permanencia en el bucle.
De esta manera nos aseguramos que al menos una vez el bloque se ejecute.
3.2.3 Bucle For
Por último, el bucle for es una sentencia especial pero muy utilizada y potente. Nos permite
resumir en una línea la forma de un bucle while. Su sintaxis es la siguiente:

Los elementos de control se definen entre los paréntesis (...) y se separan por punto y coma ; . Los
bucles anteriores en formato for serían así:
4 UNIDAD IV

Funciones
4.1 Function
Las funciones en JavaScript son bloques de código ejecutable, a los que podemos pasar
parámetros y operar con ellos. Nos sirven para modular nuestros programas y estructurarlos en
bloques que realicen una tarea concreta. De esta manera nuestro código es más legible y
mantenible.

Las funciones normalmente, al acabar su ejecución devuelven un valor, que conseguimos con el
parámetro return. Se declaran con la palabra reservada function y a continuación suelen llevar un
nombre, para poder invocarlas más adelante. Si no llevan nombre se les llama funciones
anónimas.

Veamos un ejemplo de función:

La función del ejemplo se llama saludar, y se le pasa un único parámetro, entre paréntesis (...),
que es nombre. Ese parámetro funciona como contenedor de una variable que es utilizada dentro
del bloque de código delimitado por las llaves {...}. El comando return devolverá el String que
concatena texto con el valor que contiene el parámetro nombre.

Si no pasásemos ningún valor por parámetro, obtendríamos el valor undefined.

4.2 Parámetros por defecto

Una buena práctica para evitar errores o que se tome el valor undefined sin que podamos
controlarlo, es utilizar algunos de los operadores booleanos. Si tomamos el operador OR ||
podemos asignar un valor por defecto si no está definido.
4.3 Ámbito de una función.
Por defecto, cuando declaramos una variable con var la estamos declarando de forma global y es
accesible desde cualquier parte de nuestra aplicación. Tenemos que tener cuidado con los
nombres que elegimos ya que si declaramos a una variable con el mismo nombre en varias partes
de la aplicación estaremos sobrescribiendo su valor y podemos tener errores en su
funcionamiento.

Si declaramos una variable dentro de una función, esta variable tendrá un ámbito local al ámbito
de esa función, es decir, solo será accesible de la función hacia adentro. Pero si la definimos fuera
de una función, tendrá un ámbito global.

En la versión 6 de ECMAScript tenemos los tipos de variable let y const en lugar de var y definen
unos ámbitos específicos. const crea una constante cuyo valor no cambia durante el tiempo y let
define el ámbito de la variable al ámbito donde ha sido definida (por ejemplo en una función).

Aunque tenemos definida fuera de la función la variable valor, si dentro de la función la

declaramos y cambiamos su valor, no afecta a la variable de fuera porque su ámbito (o scope) de
ejecución es diferente. Una definición de variable local tapa a una global si tienen el mismo
nombre.
5 UNIDAD V

Clases Core y Módulos de

JavaScript
Además de los tipos primitivos, JavaScript tiene unas clases, llamadas Core que forman parte del
lenguaje. Las que más se utilizan son Object, Number, Array y String. Todas ellas heredan de
Object.

5.1 Number
Es la clase del tipo primitivo number. Se codifican en formato de coma flotante con doble
precisión (Es decir, con 64 bits / 8 bytes) y podemos representar números enteros, decimales,
hexadecimales, y en coma flotante. Veamos unos ejemplos:

La clase Number incluye los números Infinity y -Infinity para representar números muy grandes:

El rango real de números sobre el que podemos operar es ~1,797x10^308 --- 5x10^-324`. También
disponemos del valor NaN (Not A Number) para indicar que un determinado valor no representa
un número:

Para crear un número podemos hacerlo con la forma primitiva o con la clase Number. Por
simplicidad se utiliza la forma primitiva.

5.1.1 Funciones de Number

JavaScript tiene 2 funciones interesantes para convertir un string en su número equivalente.
5.1.1.1 parseInt()
Devuelve el número decimal equivalente al string que se pasa por parámetro. Si se le indica la
base, lo transforma en el valor correspondiente en esa base, si no, lo devuelve en base 10 por
defecto. Veamos unos ejemplos:

5.1.1.2 parseFloat()
Función similar a parseInt() que analiza si es un número de coma flotante y devuelve su
representación decimal.

5.1.1.3 number.toFixed(x)
Devuelve un string con el valor del número number redondeado al alza, con tantos decimales
como se indique en el parámetro x.

5.1.1.4 number.toExponential(x)
Devuelve un string redondeando la base o mantisa a x decimales. Es la función complementaria a
parseFloat.

5.1.1.5 number.toString(base)
Devuelve un string con el número equivalente number en la base que se pasa por parámetro. Es la
función complementaria a parseInt.
5.2 Módulo Math
Math es una clase propia de JavaScript que contiene varios valores y funciones que nos permiten
realizar operaciones matemáticas. Estos son los más utilizados:

https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Math

5.3 Array
Es una colección de datos que pueden ser números, strings, objetos, otros arrays, etc... Se puede
crear de dos formas con el literal [...] o creando una nueva instancia de la clase Array.

Se puede acceder a los elementos del array a través de su índice y con length conocer su longitud.

Si accedemos a una posición que no existe en el array, nos devuelve undefined.

5.4 Object
Un objeto es una colección de variables y funciones agrupadas de manera estructural. A las
variables definidas dentro de un objeto se las denomina propiedades, y las funciones, métodos.
Veamos un ejemplo de objeto que recoge los datos de un libro:

Como podemos ver, las propiedades son pares clave-valor, separados por comas, y podemos
acceder a ellas de forma independiente de varias formas, con la notación punto o con la notación
array:

También podemos modificarlas de la misma manera:

Con la notación array, podemos acceder a las propiedades con variables. Ejemplo:

Pero no funciona con la notación punto:

si el objeto contiene funciones se les llama métodos. Si queremos crearlas dentro de un objeto e
invocarlas, sería así:
Para crear un objeto podemos hacerlo con la notación de llaves {...} o creando una nueva instancia
de clase:

5.4.1 Anidación
Un objeto puede tener propiedades y estas propiedades tener en su interior más propiedades.
Sería una representación en forma de árbol y podemos acceder a sus propiedades de la siguiente
manera:
5.4.2 Igualdad entre objetos
Para que dos objetos sean iguales al compararlos, deben tener la misma referencia. Debemos para
ello utilizar el operador identidad ===. Si creamos dos objetos con el mismo contenido, no serán
iguales a menos que compartan la referencia. Veamos un ejemplo:

Bibliografía
JavaScript:

https://developer.mozilla.org/es/docs/Web/JavaScript

https://www.w3schools.com/js/

Evaluación
Asistencia Practica Practica Practica Practica Examen1 Examen2
Secuencial Selectivo Repetitivo Funciones
1 = -3pts
2 = -6pts 5 5 5 10 30 45
3 = -10pts