Curso de Javascript

Historia muy rápida de Javascript

Es un lenguaje de programación que nació en el 1995 gracias a Brendan Eich. Dicen que lo hizo en una semana. 😎

Es un lenguaje que cualquier navegador puede interpretar.

En el año 1997 Brendan lleva JavaScript a ECMA y se crea la primera especificación de JS. Llamada ECMAScript 1.0.

Desde entonces hubo muchas otras estandarizaciones hasta llegar a ECMAScript 5 en el 2009. Y fue la que se usó desde entonces y que era muy completa.

En el 2015 salió ECMAScript 6 que es la nueva estandarización y que trajo muchísimas novedades en JavaScript.

¿Cómo empezamos a escribir JavaScript?

JavaScript se puede escribir en cualquier editor de código. En mi caso yo utilizo Visual Studio Code porque ya me he acostumbrado a él. Pero podéis utilizar cualquier otro como Sublime Text, Atom, Brackets, Notepad++ o incluso el Bloc de notas (¿¿are you crazy??).

Tambíen se puede escribir JS directamente en la consola del navegador. Para eso apretamos F12 y se abrirá el panel de desarrolladores. Ahí tenemos nuestra consola en la que poder escribir código.

En el caso de usar un editor de texto lo que tendremos que hacer será lo siguiente:

Crearemos un archivo HTML cualquiera.
Añadiremos el contenido que queramos o lo podemos dejar en blanco.
Dentro de nuestra etiqueta
```
<head>
```
o
```
<body>
```
añadiremos la etiqueta
```
<script></script>
```
En esa etiqueta ya podemos escribir código JavaScript directamente, pero si va a ser muy extenso recomiendo crear un archivo con extension .js y 'linkarlo' a nuestro HTML con el atributo src="" y escribir nuestro código en él.
```
<script src="rutaArchivo.js"></script>
```

Escribir comentarios en JavaScript

Para escribir comentarios existen dos maneras.


// comentario de una sola línea
esta línea no está comentada


/* comentario
de varias líneas
de texto */

Propiedades del lenguaje JavaScript

Es un lenguaje "case sensitive". Es decir, que es sensible a mayúsculas y minúsculas. Para JS no es lo mismo la palabra "Hola" que la palabra "hola".
Es de tipado débil y eso quiere decir:

Que no hace falta que digamos de qué tipo de dato es una variable. Podrá contener numero y luego cambiar a texto por ejemplo.
Se pueden sumar numeros con cadenas de texto y no dará error.
```
3 + 'hola' = '3hola'
```

Cada sentencia de código se termina con un punto y coma ;
¡OJO! No es obligatorio a día de hoy, pero en mi opinión es muy aconsejable.
Los bloques de código terminan siempre al cerrar las llaves }

Variables y Constantes

Variables

Una variable es un espacio en la memoria que reservamos para almacenar algún tipo de dato. Este dato podrá ir cambiando durante la ejecución de nuestro programa

Las variables las podemos declarar, inicializar y modificar.

Las declaramos con la palabra reservada let. ➜
```
let mivariable;
```
Las inicializamos dándole un valor con el símbolo =. ➜
```
mivariable = 23;
```
Usualmente se declaran e inicializan al mismo tiempo: ➜
```
let mivariable = 23;
```
Las modificamos asignándole un nuevo valor. (No hace falta que sea del mismo tipo). ➜
```
mivariable = '¡Hola gente!';
```

Constantes

Las constantes actuan exactamente igual que las variables pero con la diferencia de que luego no se puede modificar el valor que le hemos dado en un inicio. Se mantendrá constante... 🤔

Solo se pueden declarar y inicializar a la vez. Utilizaremos la palabra reservada const. ➜
```
const MICONSTANTE = 3.1416;
```

Por convención, está bien nombrar a las constantes en MAYÚSCULAS, para diferenciarlas fácilmente de las variables.

Ámbito de las Variables

Lo veremos más adelante en detalle pero las variables pueden ser globales o locales. Las globales se suelen declarar al principio y se pueden usar en cualquier momento, tanto dentro como fuera de bloques de código. En cambio las locales solo se pueden usar dentro del ámbito donde se hayan declarado y dejarán de existir una vez se haya cerrado el bloque que la contenga.

¡INCISO! ¿Cómo probamos nuestro código?

Para hacer pruebas usaremos unos métodos JavaScript para visualizar lo que hacemos.

```
window.alert(mivariable);
```
➜ Lo que está dentro del paréntesis lo muestra en una ventana Pop-Up y tendremos que dar a aceptar para seguir (podemos no usar el prefijo
```
window.
```
).
```
document.write(mivariable);
```
➜ Borra todo el código HTML que tengamos en la web y imprimirá lo que hay dentro del paréntesis (se usa solo para hacer alguna prueba pero no lo recomiendo).
```
console.log(mivariable);
```
➜ Lo que está dentro del paréntesis lo muestra en la consola del navegador. Esa que se llega apretando F12 o buscando las opciones de desarrollador de tu navegador (esto es lo que se usa el 90% de las veces hoy en dia).

Tipos de datos que podemos almacenar

JavaScript tiene 6 tipos de dato primitivos, de los cuales 3 son los más importantes.

Números, que pueden ser positivos, negativos, decimales, etc.
```
let numero1 = 23;
let numero2 = -7;
let numero3 = -4.16;
```
Cadenas de texto (también llamadas strings). Van siempre entre comillas, que pueden ser simples o dobles, da igual. Lo único importante es que sean o las dos simples o las dos dobles.
```
let texto1 = 'hola';
let texto2 = "hola";
let texto3 = "hola';
```
Booleanos (o lógicos). Solo tienen dos valores.
```
true
```
, que significa verdadero (o que se cumple), o
```
false
```
, que significa falso (o que no se cumple).

Luego tiene otros 3 que ya veremos más adelante.

Undefined
null
Symbol

Operadores en JavaScript

Operadores matemáticos

```
+
```
➜ Es el operador que sirve para sumar números y también para concatenar 👨‍🏫(unir, enlazar, relacionar una cosa con otra ) cadenas de texto.

```
minumero = 1 + 5; // ➜ 6
```

mitexto = 'Hola ' + 'gente!'; // ➜ 'Hola gente!'

```
-
```
➜ Resta
```
*
```
➜ Multiplicación
```
/
```
➜ División
```
%
```
➜ Módulo, que devuelve el resto que queda cuando un número se divide por otro, como cuando dividíamos con la caja en forma de L. 👨‍🏫 5 % 2 ➜ 5 módulo de 2 es 1, porque 2 por 2 son 4 y para llegar a 5 me falta 1.

¡Truco! Para hacer que un resultado en un string solo tenga un número determinado de decimales usaremos

variable.toFixed(numeroDeDecimales);

Operadores de asignación

```
=
```
➜ El símbolo igual asigna o modifica un valor a una variable o a una constante.
```
a += 3; // a = a + 3;
```
➜ Para evitarnos escribir, poniendo += hacemos que se sume directamente el valor a la variable.
```
a -= 3; // a = a - 3;
```
➜ Lo mismo pero con resta.
Es exactamente lo mismo con multiplicación, división y módulo.

Operadores de incremento y decremento

```
a++
```
➜ Lo pongas donde lo pongas a la variable a se le suma 1.
```
++a
```
➜ Es lo mismo que antes pero en ocasiones (como dentro de console.log()) hace que primero se sume 1 y luego se imprima en pantalla en lugar de a la inversa.
```
a--
```
➜ Lo pongas donde lo pongas a la variable a se le resta 1.
```
--a
```
➜ Es lo mismo que pasaba con la suma pero con resta.

¡Ejercicios!

Variables 01.- Escribir un programa que calcule el número de segundos que existen en un día. Para ello debemos crear 3 variables: horas, minutos y segundos. Multiplicaremos los segundos de un minuto por los minutos de una hora, por las horas de un día. El resultado lo guardaremos dentro de otra variable.
Como todo el mundo sabe, un día tiene 86400 segundos.

Ej. Variables 01 - Resuelto


let horas = 24; // horas que tiene el día
let minutos = 60; // minutos que tiene cada hora
let segundos = 60; // segundos que tiene cada minuto
let resultado;
resultado = horas * minutos * segundos;
console.log(resultado); // 86400

Variables 02.- Hacer un conversor de euros a dólares. Crearemos una variable llamada "euros" con un valor inicial de 7. Tenemos que calcular ese valor en dólares. Supondremos que un euro son dos dólares

Ej. Variables 02 - Resuelto


let euros = 7;
let dolares = 2; // 2 dólares son 1 euro
let resultado;
resultado = euros * dolares;
console.log(resultado); // 14

Variables 03.- El IVA para ciertos artículos es del 21%. Realiza un programa que a partir de una variable precio inicializada con valor 100, calcule el precio con IVA añadiendo el símbolo de euros al final.

Ej. Variables 03 - Resuelto


let precio = 100;
let iva = 1.21; // el  IVA se calcula multiplicando por 21 y dividiendo por 100, es decir, 1.21
let resultado;
resultado = precio * iva;
console.log(resultado + ' €'); // 121 €

Variables 04.- Realiza un programa que a partir de los valores ancho=4 y alto=7, calcule el área de un triángulo en metros cuadrados.

Ej. Variables 04 - Resuelto


let ancho = 4;
let alto = 7;
let area;
area = ancho * alto / 2; // área del triangulo = (base * altura) / 2
console.log(area + ' m2'); // 14 m2

Variables 05.- Hacer un conversor de grados centígrados a grados Fahrenheit. Para ello deberé multiplicar por 9/5 y sumar 32.
Como todo el mundo sabe, 20 grados centígrados son 68 grados Fahrenheit.

Ej. Variables 05 - Resuelto


let centigrados = 20;
let fahrenheit = (centigrados * 9/5) + 32;
console.log(fahrenheit + ' °F'); // 68 °F

Variables 06.- Vamos a mandar a un usuario una caja. Para ello, partiremos de unos valores y los concatenaremos. Hay que obtener por consola el siguiente mensaje:

[nombre] ha pedido una caja de [material] con unas dimensiones [dimensiones]. Y añade: [comentario].

Con los siguientes datos:

Ivan ha pedido una caja de madera con unas dimensiones diminutas. Y nos añade: Que sea muy bonita

Ej. Variables 06 - Resuelto


let nombre = 'Ivan';
let material = 'madera';
let dimensiones = 'diminutas';
let comentario = 'Que sea muy bonita';
console.log(nombre + ' ha pedido una caja de ' + material + ' con unas dimensiones ' + dimensiones + '. Y nos añade:  ' + comentario);

Estructuras Condicionales - Parte I

Son aquellas estructuras que devuelven una respuesta verdadera (true) o una respuesta falsa (false).

Operadores

Los operadores que se utilizan son estos:

```
>
```
➜ Mayor que...
```
<
```
➜ Menor que...
```
>=
```
➜ Mayor o igual que...
```
<=
```
➜ Menor o igual que...
```
==
```
➜ Igual que... (En este caso se considera verdadero incluso si comparamos valores de distinto tipo).
```
23 == '23' // true
```
```
===
```
➜ Igual que... (En este caso NO se considera verdadero cuando los valores a comparar son de diferente tipo).
```
23 === '23' // false
```
```
!=
```
➜ Distinto que...
```
&&
```
➜ Y... (obliga a que se cumpla una condición Y también la otra para dar true)
```
||
```
➜ O... (solo con que una de las dos condiciones se cumpla dará true)

if ➜ Si ocurre esto...haz esto.


let dato1 = 5;
let dato2 = 2;
if (dato1 > dato2) {
   console.log('El primer dato es mayor al segundo');
}

Si solo hay una cosa a hacer cuando se cumple la condición se puede escribir así:


if (dato1 > dato2) console.log('Texto cualquiera');

else if ➜ En cambio, si ocurre esto otro... entonces haz esto otro.


if (dato1 > dato2) {
   console.log('El primer dato es mayor al segundo');
} else if (dato1 == dato2) {
   console.log('Los dos datos  son iguales');
}

else ➜ En cualquier otro caso...haz esto.


if (dato1 > dato2) {
   console.log('El primer dato es mayor al segundo');
} else if (dato1 == dato2) {
   console.log('Los dos datos  son iguales');
} else {
   console.log('Nada se ha cumplido');
}

¡Ejercicios!

Condicionales 01.- Dada una constante que contiene la nota de un examen que va de 0 a 10:

Si es mayor que cinco mostrar el texto "Aprobado".
Si es igual a cinco, mostrar el texto "Aprobado por los pelos".
Si es menor que cinco, mostrar el texto "Suspendido".

Ej. Condicionales 01 - Resuelto


const NOTA = 3;
if (NOTA > 5) {
   console.log('Aprobado');
} else if (NOTA == 5) {
   console.log('Aprobado por los pelos');
} else {
   console.log('Suspendido');
}

Condicionales 02.- Declarar una constante 'I' de tipo entero y asígnale un valor. Mostrar un mensaje indicando si el valor de 'I' es positivo o negativo, si es par o impar, si es múltiplo de 5, si es múltiplo de 10 y si es mayor o menor que 100. Consideraremos el 0 como positivo.

Ej. Condicionales 02 - Resuelto


const I = 120;
let posiNega;
if (I >= 0) {
   console.log('El valor es positivo');
} else {
   console.log('El valor es negativo');
}

if (I % 2 == 0) {
   console.log('Además es par');
} else {
   console.log('Además es impar');
}

if (I % 5 == 0) {
   console.log('También es múltiplo de 5');
}

if (I % 10 == 0) {
   console.log('También es múltiplo de 10');
}

if (I > 100) {
   console.log('Y es un número mayor que 100');
} else {
   console.log('Y es un número menor que 100');
}

¡INCISO! Método Prompt

El método prompt nos permite pedirle al usuario algun dato a traves de una ventana Pop-up del navegador.


let pregunta = prompt('Dime tu nombre', 'Tu nombre va aquí');

El valor que introduzca el usuario quedará guardado, siempre como string , dentro de la variable. Si no escribe nada se guardará un string vacío y si le da a cancelar se guardará el valor null.

💪 ¡Truco! Ya que todo lo que el usuario escriba será guardado como string, cuando escribe números tenemos que convertir esa cadena a un número. Para ello usamos el método

Number()

parseInt()

parseFloat()

El primer parámetro es la pregunta que queremos hacer. Y el segundo parámetro es el texto que verá el usuario dentro de la caja en blanco, como si fuera un placeholder pero con el valor real.

¡INCISO! Template Strings

Una plantilla de cadena de texto es como un string normal pero permite una serie de cosas.

Se escriba con comillas invertidas ``.
Permite hacer saltos de línea com si de una etiqueta
```
<pre>
```
se tratara.
Podemos incrustar JavaScript dentro de la cadena de texto, para ello crearemos un bloque así:
```
${  }
```
y todo lo que vaya dentro será código (variables, funciones, bucles…).

Switch

Funciona como un if pero va revisando caso por caso con opciones establecidas.


let color = 'rojo';
switch (color){
   case 'rojo':
      console.log('Has escogido la pasion');
   break;
   case 'verde':
      console.log('Has escogido la esperanza');
   break;
   default:
      console.log('No has acertado');
}

La palabra break; lo que hace es decirle al navegador que no continúe revisando casos, sino seguiría.

El default final es como un else, si no se cumple nada eso es lo que pasará.

¡Ejercicios!

Condicionales 03.- Escribe un programa que pida dos números al usuario y después los compare, indicando si el primer número es mayor o menor que el segundo, o si son iguales.

Ej. Condicionales 03 - Resuelto


let numero1 = Number(prompt("Introduce el primer número:"));
let numero2 = Number(prompt("Introduce el segundo número:"));

if (numero1 < numero2) {
      console.log(numero1 + " es más pequeño que " + numero2);
} else if (numero1 > numero2) {
      console.log(numero1 + " es más grande que " + numero2);
} else {
      console.log(numero1 + " y " + numero2 + " son iguales");
}

Condicionales 04.- Escribe un programa que pida la hora al usuario, preguntando por las horas, minutos y segundos. Seguidamente mostrará la hora elegida por el usuario un segundo más tarde. Si no se pasa una hora correcta se mostrará un mensaje indicandolo.

Ej. Condicionales 04 - Resuelto


let hora = Number(prompt ('Dime una hora del día'));
let minutos = Number(prompt ('Dime unos minutos'));
let segundos = Number(prompt ('Dime uns segundos'));

// Verificamos todos los casos que pueden dar lugar a error
if (hora >= 0 && hora <= 23 && minutos >= 0 && minutos <= 59 && segundos >= 0 && segundos <=59) {
   segundos++;  // Se incrementan los segundos en 1
   if (segundos == 60){
      // Hay que pasar los segundos a 0 y sumar un minuto más
      segundos = 0;
      minutos++;
         if (minutos == 60) {
            // Hay que pasar los minutos a 0 y sumar una hora más
            minutos = 0;
            hora++;
         }
         if (hora == 24) { // La siguiente hora es medianoche, empieza un nuevo día
            hora = 0;
         }
   }
   console.log(`Un segundo después de la hora que has escogido serán las ${hora}h ${minutos}m ${segundos}s`);

} else {
   console.log('No has escrito una hora verdadera');
}

Condicionales 05.- Escribe un programa que pregunte al usuario qué estación del año le gusta más. Imprimir en pantalla una frase según la estación que escoja. Si se introduce un valor que no corresponda se mostrará un mensaje al usuario.

Ej. Condicionales 05 Resuelto


let estacion = prompt("¿Cuál es tu estación del año preferida?");
switch (estacion) {
   
   case "primavera":
      // si la variable estacion contiene la cadena de texto "primavera"
      // se ejecutará este bloque de código
      console.log('la que la sangre altera');
      break;
      
   case "verano":
      // si la variable estacion contiene la cadena de texto "verano"
      // se ejecutará este bloque de código
      console.log('calorcito, calorcito');
      break;
      
   case "otoño":
      // si la variable estacion contiene la cadena de texto "otoño"
      // se ejecutará este bloque de código
      console.log('que cada vez es más verano');
      break;
      
   case "invierno":
      // si la variable estacion contiene la cadena de texto "invierno"
      // se ejecutará este bloque de código
      console.log('cuando el grajo vuela bajo...');
      break;
      
   default:
      // si la variable estacion no contiene ningún nombre válido
      // se ejecutará este bloque de código
      console.log('por lo menos escribe una estación del año...😒');      
}

Condicionales 06.- Escribe un programa que pida al usuario el número del mes (un número entre 1 y 12) y que muestre el número de días que tiene ese mes. No tendremos en cuenta los años bisiestos. Si se introduce un número mayor que 12 o menor que 1, se mostrará un mensaje indicando al usuario que el mes elegido es incorrecto.

Ej. Condicionales 06 - Resuelto


let mes = prompt('Escoge un mes del año (en número)');
if ((mes >= 1) && (mes <= 12)) {
   switch (mes) {
      case ('1'):
         console.log('Enero tiene 30 días');
      break;
      case ('2'):
         console.log('Febrero tiene 28 días');
      break;
      case ('3'):
         console.log('Marzo tiene 31 días');
      break;
      case ('4'):
         console.log('Abril tiene 30 días');
      break;
      case ('5'):
         console.log('Mayo tiene 31 días');
      break;
      case ('6'):
         console.log('Junio tiene 30 días');
      break;
      case ('7'):
         console.log('Julio tiene 31 días');
      break;
      case ('8'):
         console.log('Agosto tiene 31 días');
      break;
      case ('9'):
         console.log('Septiembre tiene 30 días');
      break;
      case ('10'):
         console.log('Octubre tiene 31 días');
      break;
      case ('11'):
         console.log('Noviembre tiene 30 días');
      break;
      case ('12'):
         console.log('Diciembre tiene 31 días');
      break;
   }
}else {
   console.log('¡Tienes que poner un número del 1 al 12!');
}

Ej. Condicionales 06 - Resuelto (Opción 2)


let mes = Number(prompt("Introduce el número del mes:"));

/*
Date cuenta de que en ciertos casos no hemos utilizado el break. Así, pasamos
de un caso al siguiente para todos los meses que tengan los mismos días, hasta
llegar al caso que muestre el mensaje apropiado y salga del switch.
Con esto, evitamos la duplicación de código de console.log().
*/

switch (mes) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
      console.log("Este mes tiene 31 días.");
      break;
case 4:
case 6:
case 9:
case 11:
      console.log("Este mes tiene 30 días.");
      break;
case 2:
      console.log("Este mes tiene 28 días");
      break;
default:
      console.log("No has elegido un mes del 1 al 12");
}

Condicionales 07.- Pide al usuario 3 números y luego imprimelos ordenados de mayor a menor.

Ej. Condicionales 07 - Resuelto


let a=Number(prompt('Introduzca el primer número'));
let b=Number(prompt('Introduzca el segundo número'));
let c=Number(prompt('Introduzca el tercer número'));

console.log(`Los numeros introducidos son ${a}, ${b}, ${c}`);


if(a>=b && a>=c){ // primero mira si a es mayor que los otros dos
      if(b>c){  // si lo es, entonces comprueba si b es mayor que c
         console.log(`El orden es: ${a}, ${b}, ${c}`);  
      }else{ // o que si b es menor que c
         console.log(`El orden es: ${a}, ${c}, ${b}`); 
      }
}else if(b>=a && b>=c){ // con el resto hacemos lo mismo
      if(a>c){
         console.log(`El orden es: ${b}, ${a}, ${c}`); 
      }else{
         console.log(`El orden es: ${b}, ${c}, ${a}`);
      }
}else if(c>=a && c>=b){
      if(a>b){
         console.log(`El orden es: ${c}, ${a}, ${b}`); 
      }else{
         console.log(`El orden es: ${c}, ${b}, ${a}`); 
      }
}

Propiedades de un string

Las propiedades se llaman con la nomenclatura del punto .

Declaramos la variable 'cadena'.

let cadena = 'Hola gente!';

```
cadena.length; // 11
```
➜ Devuelve la longitud de la cadena contando espacios.

Arrays - Parte I

Estructuras que nos permiten almacenar varios datos y agruparlos.

Se pueden llenar con cualquier tipo de dato y incluso mezclar datos, pero no lo recomiendo.
Se declaran con los corchetes []
Pueden declararse vacíos o ya con contenido.


let array = []; // Array declarado pero vacío
let numeros = [1,2,3,4,5]; //Array declarado con valores

Pueden añadirse o eliminarse elementos cuando queramos.
Cada elemento del array es identificado por su indice, es decir, su posición.
Los indices empiezan a contar desde 0.


let numeros = [1,2,3,4,5];
console.log(numeros[3]); // Imprimirá el número en la posicion 3, en este caso '4'

Se puede operar con los elementos tranquilamente (sumar, concatenar, restar, etc).

Propiedad length de un Array

La propiedad length nos devolverá la longitud del Array.


let numbers = [10,23,32,41,57];
console.log(numbers.length); // 5

Ejemplo de un array con strings dentro y al que añadimos la propiedad length


let palabras = ['hola', 'que', 'tal', 'estamos'];
console.log(`La palabra "${palabras[3]}" tiene ${palabras[3].length} letras`);
   // La palabra "estamos" tiene 7 letras

¡Los string son como Arrays!

Las cadenas de texto o string se pueden considerar como un array y también se pueden recorrer letra por letra.

De la misma forma puedes acceder a una posición del string utilizando los corchetes y el índice de la letra:

   let texto = '¡Hola gente!';
console.log(texto[4]); // a

Bucles

Se usan para repetir trozos de código.

La estructura de un bucle siempre es:


Bucle {
   código a ejecutar
}

Bucle for

Es un bucle determinado ya que hay que decirle cuantas vueltas va a dar en su ejecución.

Se escribe con 3 partes:

Iniciacíon de una variable (que se suele llamar i).
Número de vueltas
Incremento o decremento de la variable


for (let i=0; i<=10; i++) {
   console.log(i); // se imprimirá una lista de 1 a 11
}

La variable empieza en 0, dará vueltas el bucle hasta llegar a 10 (en este caso 11 vueltas), y en cada vuelta la i se incrementa en uno.

Ejemplo de un if dentro de un for


for (let i=0; i<=10; i++) {
   if (i!=5 && i!=8 ) {
      console.log(i); // 0 1 2 3 4 6 7 9 10  No se imprimen ni el 5 ni el 8
   }
}

Arrays dentro de un bucle for

Hay que observar que para pasar por todas las posiciones de un array, el bucle dará tantas vueltas como el length de nuestro array.


let numbers = [15,46,37,85,41];
for (let i=0; i < numbers.length; i++) {
   console.log(`i vale ${i} y el valor de esa posición en el array es ${numbers[i]}`);
}
// i vale 0 y el valor de esa posición en el array es 15
// i vale 1 y el valor de esa posición en el array es 46
// ...

break; y continue;

Lo que hace break; es cortar el bucle donde hemos puesto la palabra y no continúa. El navegador empezará a leer despues del bucle otra vez.


let numbers = [1,2,3,4];
for (i=0; i < numbers.length; i++) {
   if(numbers[i] == 3) {
      break;
   }
   console.log(numbers[i]);
}
console.log('Mensaje después del bucle');
// 1
// 2
// Mensaje después del bucle

El caso de continue; es lo mismo que antes pero en este caso lo único que se salta es esa misma vuelta del bucle, luego sigue reproduciendolo.


let numbers = [1,2,3,4];
for (i=0; i < numbers.length; i++) {
   if(numbers[i] == 3) {
      continue;
   }
   console.log(numbers[i]);
}
console.log('Mensaje después del bucle');
// 1
// 2
// 4
// Mensaje después del bucle

Bucle for...in

Es un bucle que simplifica el bucle for normal. No tenemos que darle el numero de vueltas que tiene que dar. Lo que nos devuelve es el indice de cada valor del array.

Este tipo de bucle se utiliza sobretodo en objetos que es algo que veremos más adelante.

   
let  nombres = ['Ivan', 'Jess', 'Freya', 'Kira'];
for (let index in nombres) {
   console.log(index); // 0 1 2 3
}

Nuevo bucle for...of

Tenemos exactamente el mismo tipo de bucle que el anterior. No hace falta decirle cuantas vueltas ni cuando termina.

Lo que nos devuelve es el valor de cada posición en el array.

Veamos un ejemplo directamente


let  nombres = ['Ivan', 'Jess', 'Freya', 'Kira'];
for (let nombre of nombres) {
   console.log(nombre); // Ivan Jess Freya Kira
}

Por convención en los arrays se suelen usar nombres en plural, y dentro del bucle se usa entonces el mismo nombre en singular, así es fácil entender qué es cada cosa.

Automáticamente el bucle da el número de vueltas exacto para recorrer todo el array sin que se lo digamos.

¡Ejercicios!

Bucles 01.- Crear un bucle que imprima por consola la lista de números del 1 al 30, incrementándose de 3 en 3.

Ej. Bucles 01 - Resuelto


for (i=1; i<=30; i+=3) {
   console.log(i); // 1 4 7 10 13 16 19 22 25 28
}

Bucles 02.- Utiliza un bucle for para imprimir por la consola la tabla de multiplicar del 8. Y luego otro con las 10 tablas de multiplicar de toda la vida.

Ej. Bucles 02 - Resuelto


for (i=1; i<=10; i++) {
   console.log(`8 x ${i} = ${8*i}`); 
}        // 8 x 1 = 8
         // 8 x 2 = 16
         //...
// Segunda Parte
for (i = 1; i <= 10; i++) {
   for (j=1; j <=10; j++) {
      console.log(`${i} x ${j}=${i * j}`);
   } 
}

Bucles 03.- Escribe un programa que saque una lista de números del 1 al 10 y que indique si el número es par o impar.

Ej. Bucles 03 - Resuelto


for (i=1; i<=10; i++) {
   if (i % 2 == 0){
      console.log(`${i} es par`);
   }
   else {
      console.log(`${i} es impar`); 
   }
}           // 1 es impar
            // 2 es par
            // 3 es impar
            // ...

Bucles 04.- Escribe un programa que muestre los números del 1 al 50, con las siguientes excepciones:

Para los múltiplos de 3 muestra la palabra "Fizz" en lugar del número.
Para los múltiplos de 5 muestra la palabra "Buzz" en lugar del número.
Para los múltiplos de 3 y 5 muestra la palabra "FizzBuzz" en lugar del número.

Ej. Bucles 04 - Resuelto


for (i=1; i<=50; i++) {

   if ((i % 3 == 0) && (i % 5 != 0)) {                
      console.log('Fizz');                            // 1
   } else if ((i % 5 == 0) && (i % 3 != 0)) {         // 2 
      console.log('Buzz');                            // Fizz
   } else if ((i % 3 == 0) && (i % 5 == 0)) {         // 4
      console.log('FizzBuzz');                        // Buzz
   } else {                                           // ...
      console.log(i);
   }   
}

También se podría empezar con FizzBuzz como primera regla if y así estaria por encima de las otras dos reglas que también se cumplen.

Bucles 05.- Haz un programa que pida una frase al usuario en minúsculas. Imprimeremos el número total de letras "a" que hay en la frase.

Ej. Bucles 05 - Resuelto


let frase = prompt('Escribe una frase en minúsculas y te diré cuantas vocales "a" tiene');
let contador = 0;

for (let letra of frase) {
   if (letra  == 'a') {
      contador++;
   }
}
console.log(`Tu frase tiene ${contador} aes.`);

Bucle while

Con el bucle while podemos conseguir casi lo mismo que con el bucle for. La diferencia más importante es que con while no hace falta saber cuantas vueltas tendrá que dar el bucle. Simplemente las seguirá dando mientras se cumpla la condición.


let contador = 0;
while (contador <= 5) {
   console.log('Contador es igual a ' + contador);
   contador++
}  // 0 1 2 3 4 5

¡OJO! Cuidado con olvidarte de poner la sentencia de incremento (en este caso

contador++;

ya que puedes hacer que se carge un bucle infinito, cosa que no pasa tan fácilmente con el bucle for.

¿Cómo saber cual usar entonces? Cuando sepas cuantas vueltas tiene que dar el bucle usa for y cuando no lo sepas usa while.

Bucle do...while

En este caso, la diferencia entre los dos es que en el bucle while el código a ejecutar no empezará a no ser que se cumpla la condición. Si no se cumple nunca se ejecuta y con do...while el código se ejecuta mínimo una vez y luego ya se repetirá si la condición se cumple.


do {
   código a ejecutar
} while (condicion)


let pass = 'hola';
do {
   pass = prompt('Pon tu contraseña');
} while (pass != 'hola')

Como veis en este caso, aunque la condición ya no se cumpla porque pass SÍ que es igual a 'hola', el navegador sigue ejecutando el código que pide al usuario la contraseña.

¡Ejercicios!

Bucles 06.- Escribe un programa que pida al usuario introducir un número entero mayor que 10, el cuadro de texto volverá a aparecer si el número es menor.

Ej. Bucles 06 - Resuelto


let numero = 0; // Valor inicial que permite entrar en el bucle
while (numero <= 10) {
   numero = Number(prompt("Introduce un número mayor que 10"));
}

Bucles 07.- Escribe un programa que pida al usuario introducir un número entero entre 50 y 100, el cuadro de texto volverá a aparecer si el número es menor o mayor.

Ej. Bucles 07 - Resuelto


let numero = 0; // Valor inicial que permite entrar en el bucle
while ((numero < 50) || (numero > 100)) {
      numero = Number(prompt("Para terminar el bucle, introduce un número entre 50 y 100:"));
}

Bucles 08.- En primer lugar se le pedirá al usuario que introduzca un número entre 2 y 10. Si el número no está entre estos dos valores, se le seguirá pidiendo hasta que introduzca el valor correcto. Una vez haya introducido un valor entre 2 y 10, se mostrará por consola la tabla de multiplicar del número elegido.

Ej. Bucles 08 - Resuelto


let tabla = 1; // Valor inicial que permite entrar en el bucle
while (tabla < 2 || tabla > 10) {
   tabla = Number(prompt ('¿Qué tabla de multiplicar quieres? Solo del 2 al 10'))
}
let i = 1; // Variable contador. Usamos el incremento para obtener el valor de cada vuelta
while (i <= 10) {
  console.log(`${tabla} x ${i} = ${tabla * i}`);
  i++;
}

Bucles 09.- Construye y muestra por consola un "triángulo" de 7 líneas como el siguiente:
*
**
***
****
*****
******
*******

Ej. Bucles 09 - Resuelto


let estrellas = '';
let i = 1;
while (i <= 7) {
   estrellas += '*';
   console.log(estrellas);
   i ++;
}

Bucles 10.- Hay que crear un programa de JS que permita adivinar un número secreto entre 1 y 100. Se considera que cuando el usuario introduce un valor, éste es siempre válido. Con cada intento del jugador, el programa le dice si el número secreto es mayor o menor. El jugador tiene 6 intentos para adivinar el número.

💪 ¡Ayuda! Para crear el número aleatorio le daremos a una variable el valor

Math.floor((Math.random() * 100) + 1);

Ej. Bucles 10 - Resuelto


let solucion = Math.floor(Math.random() * 100) + 1; // numero aleatorio
let contador = 6; // numero de intentos
let numeroUsuario = Number(prompt('Dime un numero entre 1 y 100 a ver si lo adivinas'));
while (contador > 1){
   if (numeroUsuario < solucion) {
      console.log(`El número secreto es mayor que ${numeroUsuario}`);
      numeroUsuario = Number(prompt(`No has acertado, prueba otra vez, te quedan ${contador-1} oportunidades`));
      
   } else if(numeroUsuario > solucion) {
      console.log(`El número secreto es menor que ${numeroUsuario}`);
      numeroUsuario = Number(prompt(`No has acertado, prueba otra vez te quedan ${contador-1} oportunidades`));
   } else {
      console.log('¡Bravo, has acertado!');
      break;
   }

   contador--
}
if (contador == 1) console.log('Ohhhhhhhh el número era ' + solucion);

Bucles 11.- Crea un array con cinco nombres de persona y recórrelo mostrando el texto "Conozco a alguien llamado..."

Ej. Bucles 11 - Resuelto

      
const nombresDePersonas = ['Ivan', 'Jess', 'Freya', 'Kira'];

for(nombre in nombresDePersonas) {
   console.log('Conozco a alguien llamado ' + nombresDePersonas[nombre]);
}
// Conozco a alguien llamado Ivan
// Conozco a alguien llamado Jess
// Conozco a alguien llamado Freya
// Conozco a alguien llamado Kira

Ej. Bucles 11 - Resuelto - Opción 2

            
const nombresDePersonas = ['Ivan', 'Jess', 'Freya', 'Kira'];

for(let nombre of nombresDePersonas) {
   console.log('Conozco a alguien llamado ' + nombre);
}
// Conozco a alguien llamado Ivan
// Conozco a alguien llamado Jess
// Conozco a alguien llamado Freya
// Conozco a alguien llamado Kira

Bucles 12.- Recorrer la siguiente lista con un bucle, imprimiendo el doble de cada número:

```
my_list = [1,9,3,8,5,7];
```

Ej. Bucles 12 - Resuelto

      
const my_list = [1, 9, 3, 8, 5, 7];

for(numero of my_list) {
   let numeroDoble = numero * 2;
   console.log(`${numeroDoble} es el doble de ${numero}`);
}

// 2 es el doble de 1
// 18 es el doble de 9
// 6 es el doble de 3
// 16 es el doble de 8
// 10 es el doble de 5
// 14 es el doble de 7

Bucles 13.- En un array cualquiera con 10 números, contar cuantos números positivos hay, cuantos negativos y cuantos ceros.

Ej. Bucles 13 - Resuelto

            
const listaNumeros = [1, -5, 2, 0, -14, 7, 8, 0, -1, 23];
let positivos = 0;
let negativos = 0;
let ceros = 0;

for(numero of listaNumeros) {
   if(numero > 0) positivos++;
   else if(numero < 0) negativos++;
   else ceros++; 
} 
console.log(`Hay ${positivos} números positivos.`); 
console.log(`Hay ${negativos} números negativos.`);
console.log(`Hay ${ceros} números cero.`);

// Hay 5 números positivos.
// Hay 3 números negativos.
// Hay 2 números cero.

Métodos de los strings

Los strings se consideran objetos así que también tienen unos métodos preestablecidos.

Todos los métodos devuelven cadenas nuevas pero sin modificar la original.

Se escriben con un punto .
Los métodos son todo lo que puede hacer un string. Debe llevar paréntesis y dentro se colocan parámetros. ( )

Declaramos la variable 'cadena'.

let cadena = 'Hola gente!';

```
cadena.toUpperCase(); // 'HOLA GENTE!'
```
➜ Devuelve la cadena pasada a mayúsculas.
```
cadena.toLowerCase(); // 'hola gente!'
```
➜ Devuelve la cadena pasada a minúsculas.
```
indexOf('o'); // 1
```
➜ Devuelve la posición donde está el texto que hemos puesto dentro del paréntesis. Pueden ser letras sueltas o varias letras.
¡OJO! Recuerda que los índices siempre empiezan en 0. Por lo tanto en este caso
```
0  1  2  3

H  o  l  a
```

cadena.replace(valor a buscar , valor nuevo);

➜ Busca el primer parámetro y lo cambia por el segundo parámetro.

cadena.replace('gente' , 'people'); // 'Hola people!''

```
cadena.substring(donde empieza [,donde acaba]); 
```
➜ Crea un string empezando en la posición del primer parámetro y acabando en la posición ANTES del segundo parámetro. Si no hay segundo parámetro acabará al final.
```
cadena.substring(3); // 'a gente!'
```
```
cadena.substring(3, 7); // 'a ge'
// La posicion 7 está en la n así que corta uno antes
```
```
cadena.slice(donde empieza [,donde acaba]); 
```
➜ Igual que substring pero se pueden poner valores negativos, que los cuenta empezando desde el final.
```
cadena.slice(2, -3); // 'la gen'
```
```
cadena.substr(donde empieza [,longitud]); 
```
➜ Parecido a substring y slice pero en el segundo parámetro tenemos que poner la longitud de texto, no la posición final.
```
cadena.substr(2, 2); // 'la'
```
```
cadena.trim(); 
```
➜ Elimina todos los espacios al principio y al final (muy útil en formularios).
```
let cadena2 = '   Hola! ';
cadena.trim(); // 'Hola!'
```
```
cadena.split(); 
```
➜ Convierte la cadena en un array. Si no ponemos ningún parámetro, todo el string se quedará en la posición 0 del array. Si escribimos algo, ESE ALGO será el marcador que separe los elementos del array.
```
   let cadena3 = 'Hola tu!';
cadena.split(); // ['Hola tu!']
cadena.split(""); // ['H', 'o', 'l', 'a', ' ', 't', 'u', '!']
cadena.split(" "); // ['Hola', 'tu!']
```

Métodos nuevos de ES6:

```
cadena.startsWith(valor [,inicio]); 
```
➜ Devuelve true o false si la cadena empieza con la letra que hemos puesto. En el segundo parámetro podemos poner la posición donde queremos “mirar”
```
cadena.startsWith('H'); // true
```
```
cadena.startsWith('en', 6); // true
```
```
cadena.endsWith(valor [,inicio]); 
```
➜ Hace lo mismo que el anterior pero mirando si acaba en la letra que hemos dicho. El segundo parámetro en este caso es la longitud del texto que cogeremos para “mirar” si se cumple.
```
cadena.endsWith('!'); // true
```
```
cadena.endsWith('a', 4); // true
```
```
cadena.includes(valor [,inicio]); 
```
➜ Devuelve true o false si el valor del primer parámetro está en algún sitio del string. En el segundo parámetro podemos poner desde dónde empezar a contar.
```
cadena.includes('a'); // true
```
```
cadena.includes('a', 5); // false
```

cadena.repeat(2); // 'Hola gente!Hola gente!'

➜ Repite el string el número de veces que le digamos.

'Ja'.repeat(4); // 'JaJaJaJa'

Objeto Math

Es un objeto que utilizamos para hacer operaciones matemáticas más complejas

Propiedades del Objeto Math

Voy a mostrar 3 propiedades básicas:

```
Math.E; // 2.718281828459045
```
➜ Devuelve la constante de Euler
```
Math.PI; // 3.141592653589793
```
➜ Devuelve la constante PI
```
Math.SQRT2; // 1.4142135623730951
```
➜ Devuelve la raíz cuadrada de 2

Métodos del Objeto Math

```
Math.sqrt(16); // 4
```
➜ Devuelve la raíz cuadrada del valor.
```
Math.abs(-5); // 5
```
➜ Devuelve el valor absoluto de un número. 👨‍🏫Es decir el número sin signo.
```
Math.ceil(3.1); // 4
```
➜ Devuelve el valor entero siguiente por arriba. Da igual que esté muy cerca al de abajo, siempre redondeará al alza.
```
Math.floor(2.7); // 2
```
➜ Devuelve el valor entero siguiente por debajo. Da igual que esté muy cerca al de arriba, siempre redondeará a la baja.
```
Math.round(2.3); // 2
```
```
Math.round(2.7); // 3
```
➜ Devuelve el valor de un número redondeado al entero más cercano, o por arriba o por abajo.
```
Math.pow(2,3); // 2 elevado a 3    8
```
➜ Devuelve una potencia, el primer valor elevado al segundo valor.
```
Math.random();
```
➜ Devuelve un número aleatorio decimal entre 0 y 1. Por ejemplo el 0.6193073877128641.

¡Truco! Para pedir un número aleatorio entre dos números utilizamos la siguiente fórmula:

Math.floor(Math.random() * (max-min)+min);

```
Math.sign(-2); // -1

Math.sign(4);  //  1

Math.sign(0);  //  0
```
➜ Devuelve el signo que tenga el valor. Si es negativo devuelve -1, si es positivo devuelve 1 y si es 0 devuelve 0.

Métodos de los Arrays

Igual que en los strings, los Arrays también tienen una serie de métodos que podemos utilizar. Funcionan de la misma manera que los métodos de un String.

Declaramos el array numeros.

let numeros = [1,2,3,4,5];

```
Array.isArray(numeros); // true
```
➜ Devuelve true si lo que está entre los paréntesis ES UN ARRAY.
```
numeros.shift(); // [2,3,4,5]
```
➜ Elimina la primera posición del array.
```
numeros.pop(); // [1,2,3,4]
```
➜ Elimina la última posición del array.

¡Truco! Podemos guardar el elemento eliminado del array con shift o con pop si se lo metemos en una variable de esta manera:

let elementoGuardado = numeros.shift();
console.log(elementoGuardado); // 1

```
numeros.push(6, 'adios'); // [1,2,3,4,5,6,'adios']
```
➜ Añade el elemento en la última posición del array.
```
numeros.unshift(0, 'hola'); // ['hola',0,1,2,3,4,5]
```
➜ Añade el elemento en la primera posición del array.
```
numeros.indexOf(3); // 2
```
➜ Devuelve el índice del primer elemento que coincida con el valor que hemos dado. Deveuvle -1 si no existe.
```
numeros.lastIndexOf(3); // 2
```
➜ Igual que la version con indexOf. La diferencia es que nos dice el primero que encuentra desde atrás, aunque el índice que nos da es el normal.
```
numeros.reverse(); // [5,4,3,2,1]
```
➜ Invierte el orden de los elementos del array.

         numeros.join(); // "1,2,3,4,5"

numeros.join(' ') // "1 2 3 4 5"

numeros.join('/') // "1/2/3/4/5"

➜ Devuelve un string con el separador que indiquemos. Por defecto utilizará comas.

```
numeros.splice(2); // [1,2]

numeros.splice(2,2); // [1,2,5]

numeros.splice(2,2,5,'hola',-4) // [1,2,5,'hola',-4]
   
```
➜ Si solo ponemos un valor, elimina desde la posición dada (ella incluída) hasta el final.
➜ Si ponemos dos valores, el primero dice donde empieza a cortar, y el segundo cuantas posiciones eliminará. Al final dejara los elementos restantes dentro del Array.
➜ Si ponemos más valores, actuará igual que la segunda versión y simplemente añadirá todos los valores que le hemos dado en la posición indicada. ¡Truco! Si solo queremos añadir elementos por en medio de un Array sólo tenemos que dejar la segunda cifra en 0 y añadirá los elementos en la posición que le hayamos dicho con el primer valor.
```
let nuevoArray = numeros.slice(2);

console.log(nuevoArray); // [3,4,5]

nuevoArray = numeros.slice(1,4);

console.log(nuevoArray); // [2,3,4]
```
➜ Slice corta un pedazo de Array y lo devuelve a una nueva variable. Si solo ponemos un valor cortará desde ahí hasta el final, y si ponemos dos cortara desde la posición dada por el primer valor hasta la posición dada por el segundo valor.
➜ Si ponemos números en negativo empezará a contar desde atrás.


let array1 = ['¿Hola', 'qué'];
let array2 = ['tal', 'estás?'];
let arrayConcat;

```
arrayConcat = array1.concat(array2); // ['¿Hola', 'qué','tal', 'estás?']
```
➜ Concatena un array con otro. Al primero que pongas le suma el que tenga en el paréntesis.

¡INCISO! Operador Ternario

En realidad estaríamos hablando de un operador más, pero como se comporta casi como un if...else lo he querido añadir aquí.

Se utiliza cuando una condición va a ser true o false.

Hay 2 casos, si cuando es true o false y sólo queremos añadir una sentencia en cada uno:


(condición) ? sentenciaParaTrue : sentenciaParaFalse


let num = 2;           //true                    false
(num % 2 == 0) ? console.log('Es par') : console.log('es impar');

O cuando queremos añadir varias sentencias dentro de true o de false.


(condición) ?
   (primera sentencia, // importante la coma
   segunda sentencia)
   :
   (primera sentencia, // importante la coma
   segunda sentencia);


let num = 3;
(num % 2 == 0) ? 
(
   console.log('Es par'),
   console.log('Te repito que es par')
)
   : 
(
   console.log('Es impar'),
   console.log('Te repito que es impar')
);

¡Ejercicios!

Bucles 14.- Realiza un programa que pida cadenas de texto hasta que se pulse “cancelar”.
Al salir con “cancelar” deben mostrarse todas las cadenas concatenadas con un guión "-".

El resultado no puede empezar con un guión.
Si se escribe un espacio no se concatenará.
Si no se escribe nada no se concatenará nada.

Ej. Bucles 14 - Resuelto

               
let resultado = "";
do {
   let texto = prompt("Introduce un texto");
   if(texto != null) {
      texto = texto.trim();
   } else {
       texto = "";
   }

   //si la variable resultado está vacía
   if ((resultado == "") && (texto != "")) {
      // concatenamos sin el guión
      resultado += texto;

   }// concatenamos usando guión
    else if ((resultado != "") && (texto != "")) {
       resultado += "-" + texto;

    } else {
         resultado = resultado;
      }

// mientras se pulse aceptar en el confirm...
} while (confirm("¿Quieres seguir?"));

// si se pulsa cancelar imprimimos el resultado
console.log(resultado);

Bucles 15.- Escribe un programa que pida un número entero mayor que 1 y que escriba si el número es primo o no. Un número primo es aquel que solo es divisible por sí mismo y la unidad

Ej. Bucles 15 - Resuelto

                           
let num = Number(prompt('Introduce un número'));
let divisores = 0;

if (num === 1) console.log('El número uno no vale')
else {

   for (i = 2; i < num; i++ ) { 
      if (num % i==0){ 
         console.log(num + "/" + i + "=" + num/i + "-> No es primo");
         divisores++;
         break;
      }
   }
}

if (divisores == 0) console.log(`${num} es primo`)

Bucles 16.- Escribe un programa que permita ir introduciendo una serie indeterminada de números mientras su suma no supere 50. Cuando esto ocurra, se debe mostrar el total acumulado y el contador de cuantos números se han introducido.

Ej. Bucles 16 - Resuelto

                                 
let suma = 0;
let contador = 0;

while (suma < 50) { 
   suma +=Number(prompt('Introduce un número para añadir a la suma'));
   contador++; 
} 
console.log(`La suma total es de: ${suma}`); console.log(`El total de números introducidos es: ${contador}`);

Bucles 17.- Crea 3 arrays.

El primero tendra 5 números y el segundo se llamará pares y el tercero impares, ambos estarán vacíos.
Después multiplica cada uno de los números del primer array por un número aleatorio entre 1 y 10, si el resultado es par guarda ese número en el array de pares y si es impar en el array de impares.
Muestra por consola:

La multiplicación que se produce junto con su resultado con el formato 2 x 3 = 6
El array de pares e impares.

Ej. Bucles 17 - Resuelto


const numeros = [3,5,20,22,71];
let pares = [];
let impares = [];

for (numero of numeros) {
   let aleatorio = Math.round((Math.random() * 10) + 1);
   let resultado = numero * aleatorio;

   console.log(`${numero} x ${aleatorio} = ${resultado}`);
   if (resultado % 2 == 0) {
      pares.push(resultado);
   }else {
      impares.push(resultado);
   }
}
console.log(pares);
console.log(impares);

Bucles 18.- Haz un programa que pida el número de DNI sin la letra. Lo que hará el programa es devolver el mismo número con la letra que debería tener.

El número no puede ser negativo ni tener más de 8 dígitos.

Te doy un array de letras

const letras = ['T', 'R', 'W', 'A', 'G', 'M', 'Y', 'F', 'P', 'D', 'X', 'B', 'N', 'J', 'Z', 'S', 'Q', 'V', 'H', 'L', 'C',
   'K', 'E', 'T'];

La posición de la letra que deberás añadir al DNI es la del resultado del MÓDULO del número introducido entre 23:

Ej. Bucles 18 - Resuelto

   
const letras = ['T', 'R', 'W', 'A', 'G', 'M', 'Y', 'F', 'P', 'D', 'X', 'B', 'N', 'J', 'Z', 'S', 'Q', 'V', 'H', 'L', 'C', 'K', 'E', 'T'];

let dni = prompt('Introduce tu DNI sin letra');

if (dni.length==8 && parseInt(dni)>0) {
   console.log(`Tu DNI completo es ${dni}${letras[dni%23]}`);
}

Bucles 19.- Solicitar al usuario una palabra y mostrar por consola el número de consonantes, vocales y longitud de la palabra.

Ej. Bucles 19 - Resuelto

      
const palabra = prompt('Introduce una palabra').toLowerCase();

let consonantes = 0;
let vocales = 0;

for (letra of palabra){
   if(letra == 'a' || letra == 'e' || letra == 'i' || letra == 'o' || letra == 'u'){
      vocales++;
   }else {
      consonantes++;
   }
}

console.log(`Tu palabra tiene ${vocales} vocales, ${consonantes} consonantes y tiene un total de ${palabra.length} letras.`);

Funciones Parte I

Podríamos decir que las funciones son bloques de código que podemos guardar para utilizar más adelante.

Las declaramos con la palabra reservada

function

Los nombres de las funciones vienen seguidas de dos paréntesis () que pueden tener atributos dentro.

function nombreFuncion()

Todo el bloque de código de la función irá entre llaves {}.


function decirHola() {
   console.log('Hola');
}

Ahora ya tenemos nuestro bloque de código almacenado con el nombre decirHola. Lo podremos usar en cualquier parte de nuestro código. Solo nos faltará llamar o invocar a esa función cuando la necesitemos. Para ello pondremos simplemente el nombre seguido de los paréntesis.

decirHola();

Lo que hará esta funcion cada vez que la llamemos será imprimir "Hola" en consola.

Retorno de una función

Ya hemos visto que las funciones ejecutan un código cuando las llamamos. Pero tambien devuelven un valor de retorno cuando se ejecutan. Un valor que si no le indicamos lo contrario será siempre undefined.

Para decirle que retorne algo utilizamos la palabra reservada

return;


function decirHola() {
   return 'Hola';
}
let retornoFuncion = decirHola();
console.log(retornoFuncion); // Hola


function decirHola() {
   let palabra1 = 'Hola';
   let palabra2 = ' gente!';
   return palabra1 + palabra2;
}
console.log(decirHola()); // Hola gente!

¡OJO! Una cosa muy importante a tener en cuenta es que todo el código que haya despues de un return no se va a ejecutar.

Parámetros de una función

A veces, las funciones necesitan cierta información para ejecutar su código. Los valores requeridos por la función se llaman parámetros, y se definen entre paréntesis () justo detrás del nombre de la función. Estos valores pueden ser utilizados en el cuerpo de la función.


function decirHola(nombre) {
         let mensaje = 'Hola ' + nombre;
         return mensaje;
      }
      console.log(decirHola("Ivan")); // Hola Ivan
      console.log(decirHola("Jess")); // Hola Jess

En el momento de llamar a la función es cuando pasamos un valor concreto a los parámetro de la función. A los valores que le damos a los parámetros en el momento de llamar a la función, se les llama argumentos. En el ejemplo anterior, definimos la función

decirHola(nombre)

, en este caso nombre es el parámetro de la función. Cuando llamamos a la función decirHola , los valores "Ivan" y "Jess" son los argumentos.

Cuando una función acepta varios parámetros, el número y orden de los parámetros es muy importante que se respete:


function presentacion(nombre, edad) {
   console.log(`Me llamo ${nombre} y tengo ${edad} años`);
}

presentacion("Ivan", 32); // OK  -  Me llamo Ivan y tengo 32 años
presentacion(34, "Jess"); // Argumentos invertidos  -  Me llamo 34 y tengo Jess años
presentacion(32); // falta 1 argumento  -  Me llamo 32 y tengo undefined años

Argumentos predefinidos

Una función que tenga parámetros en el momento de ser creada va a necesitar sí o sí que al ser invocada se le añadan el mismo número de argumentos.

Si no se le da un argumento, la función lo transformará en undefined. Para evitar que eso pase podemos darle un valor predefinido a uno de los parámetros.


function suma(a, b, c = 3) {
   console.log( a + b + c );
}
suma( 2, 4 ); // 9

Como puedes ver, aunque no hayamos pasado un tercer argumento, la función coge el predefinido al crearla.

Si le diéramos un argumento cuando la invocamos cogerá el valor nuevo que le damos, no el predefinido.

Funciones anónimas

También podemos llamar a las funciones sin ningún nombre. De esta forma se pueden asignar a variables o a otras funciones.


let decirHola = function(nombre) {
   let mensaje = 'Hola ' + nombre;
   return mensaje;
};
console.log(decirHola('Ivan')); // Hola Ivan

Para ejecutarlas solo tenemos que llamar a la variable con paréntesis al final y los argumentos que queramos dar.

También se le puede dar un argumento al final de la sentencia para definir y ejecutar la función automaticamente.


let decirHola = function(nombre) {
   let mensaje = 'Hola ' + nombre;
   return mensaje;
}('Ivan'); // Aquí le damos el argumento que queramos antes del punto y coma
console.log(decirHola); // Hola Ivan

¡Ejercicios!

Funciones 01.- Crear una función llamada "hoyQuieroComer" que recibe un parámetro “comida” cuyo valor cuando la llamemos(argumento) será "garbanzos".
Cuando llamemos a la función se mostrará un log indicándonos lo que deseamos comer. Haz varias pruebas con comida diferente.

Ej. Funciones 01 - Resuelto

   
function hoyQuieroComer(comida) {
   console.log('Hoy quiero comer ' + comida);
}

hoyQuieroComer('garbanzos');
// Hoy quiero comer garbanzos

Funciones 02.- Crear y llamar a una función que recibe un número y calcula su cubo.

Ej. Funciones 02 - Resuelto

      
function calcularCubo(numero) {
   const resultado = numero * numero * numero;
   console.log('El cubo del numero es ' + resultado);
}

calcularCubo(3);
// El cubo del numero es 27

Funciones 03.- Crear y llamar a una función que recibe la velocidad en Km/hora y la muestra en metros/segundo.

Ej. Funciones 03 - Resuelto

         
function conversionKmHora(velocidad) {
   const resultado = (velocidad * 1000) / 3600;
   console.log(`Esos km/h equivalen a ${resultado.toFixed(2)}m/s`);
}
   
conversionKmHora(60);
//Esos km/h equivalen a 16.67m/s

Funciones 04.- Crea y llama a una función que reciba el ancho y el alto de un triángulo y que calcule su area.

Ej. Funciones 04 - Resuelto

            
function areaRectangulo(ancho, alto) {
   const resultado = (ancho * alto) / 2;
   console.log(`El area del triángulo es ${resultado.toFixed(2)}`);
}

areaRectangulo(10, 15)
//El area del triángulo es 75

Funciones 05.- Crea una función que reciba 2 parámetros, precio e iva, y devuelva el precio con iva incluido. Si no recibe el iva, aplicará el 21 por ciento por defecto.

Ej. Funciones 05 - Resuelto

               
function masIva(precio, iva = 21) {

   let coniva = (precio + precio * iva / 100);
   return coniva;
}
let precio = Number(prompt("Introduce un precio"));
let iva = Number(prompt("Introduce el iva"));
let resultado = 0;

if (iva > 0) {
   resultado = masIva(precio, iva);
} else {
   resultado = masIva(precio);
}
console.log("Precio sin iva: " + precio);
console.log("Precio más Iva: " + resultado);

Funciones estándar

Además de poder crear nuestras propias funciones. Javascript tiene predefinidas una serie de funciones que facilitan algunas tareas.

```
   isNaN(valor);
```
➜ Esta función booleana significa "is Not a Number" y devuelve true si el valor introducido NO ES UN NÚMERO. Si queremos pedirle si es un número le ponemos el signo de admiración delante que lo que hace es invertir el valor booleano.
```
            
               isNaN(23); // false
            
```
```
            
               !isNaN(23); // true
            
```

            
               parseInt(valor);

➜ Esta función convierte el string con números que tenga en su interior en un número. Si pones un decimal lo redondea a la baja. Puede tener letras siempre y cuando vayan después del número.


   parseInt('15'); // 15
   parseInt('15.5'); // 15
   parseInt('15 hola!'); // 15
   parseInt('hola 15'); // NaN (no es un número)

               
                  parseFloat(valor);

➜ Hace lo mismo que la anterior función pero devuelve números decimales.


   parseFloat('23.7'); // 23.7
   parseInt('17.5 hola!'); // 17.5
   parseInt('hola 18.3'); // NaN (no es un número)

¡Novedad EcmaScript 6! Arrow Functions

Con la llegada de ES6 llega una nueva manera de declarar a las funciones. Y se llaman arrow functions (funciones flecha).

nombre de la función = (parámetros) => {cuerpo o valor devuelto}


// Antigua forma de escribir funciones
function saludar(nombre, apellido) {
   console.log(`¡Hola ${nombre} ${apellido}!`);
}
// Nueva forma de escribir funciones
const saludar = (nombre, apellido) => {
   console.log(`¡Hola ${nombre} ${apellido}!`);
}

Objetos Parte I

Para explicar lo que son los objetos en programación los vamos a comparar con un objeto en la vida real, por ejemplo un lápiz.

Propiedades de los Objetos

Hay una serie de cosas que caracterizan al lápiz, como por ejemplo que es de madera, que es duro o blando, que es de un color determinado, etc. A todo esto le llamamos propiedades, pues pasará lo mismo en JavaScript. Los objetos tendrán unas propiedades que dirán características de nuestros objetos

Creación de un objeto

Para crear un objeto lo hacemos a través de las llaves {} y dentro pondremos las propiedades con sus valores.

   
let personaje = {
nombre: 'Gandalf',
vida: 100,
amigos: ['Bilbo', 'Radagast']
};

Llamar a una propiedad - Nomenclatura del punto .

Para llamar a cada propiedad utilizamos el punto seguido del nombre de la propiedad.

nombreObjeto.nombrePropiedad


console.log(personaje.nombre); // Gandalf
console.log(personaje.vida); // 100
console.log(personaje.fuerza); // 35
console.log(personaje.amigos[0]); // Bilbo
console.log(personaje.amigos[1]); // Radagast

Si tuviéramos muchísimas propiedades hay una manera que ya conocemos para recorrer el objeto y ver todas las propiedades. El bucle for...in


for (let propiedad in personaje) {
   console.log(propiedad);
}
// nombre
// vida
// amigos

Y si lo que queremos es acceder a todos los valores de cada propiedad lo haríamos así:


for (let propiedad in personaje) {
   console.log(personaje[propiedad]);
}
// Gandalf
// 100
// 0: "Bilbo"
// 1: "Radagast"

Como veis estamos tratando al objeto como un array pero en realidad no lo es, y si intentáis usar el bucle for...of como hemos hecho anteriormente vereis que da error, porque en este caso personaje no es un array.

No obstante sí que podemos utilizar for...of para recorrer el array dentro del objeto personaje.


for (let amigo of personaje.amigos) { 
   console.log(amigo);
}
// Bilbo
// Radagast

También se puede llamar a la propiedad con corchetes [] pero solo se utiliza en algunas ocasiones.


let nombrePropiedad = 'nombre';
let miObjeto = {
nombre: 'Gandalf',
vida: 100
};
   console.log(miObjeto[nombrePropiedad]); // Gandalf

En este caso no podríamos haber utilizado el punto

miObjeto.nombrePropiedad

porque hubiera buscado la variable nombrePropiedad, que no existe.

También se utilizan corchetes cuando la propiedad tiene espacios por ejemplo:


let miObjeto = {
nombre: 'Gandalf',
'mi vida': 100
};
console.log(miObjeto['mi vida']); // 100

Añadir una propiedad a un objeto

Para añadir una propiedad, es tan sencillo como llamar a esa propiedad como si ya existiera y asignarle un valor.


let personaje = {
   nombre: 'Gandalf',
}
for(let propiedad in personaje) {
   console.log(propiedad);
   console.log(personaje[propiedad]);
}
// nombre
// Gandalf

personaje.vida = 100; // he creado la propiedad vida con el valor 100

for(let propiedad in personaje) {
   console.log(propiedad);
   console.log(personaje[propiedad]);
}
// nombre
// Gandalf
// vida
// 100

Modificar la propiedad de un objeto

Además de llamar y de crear nuevas propiedades, podemos modificar el valor de una propiedad simplemente asignandole uno nuevo.


let personaje = {
nombre: 'Gandalf',
vida: 100,
amigos: ['Bilbo', 'Radagast']
};
console.log(personaje.nombre); // Gandalf

personaje.nombre = 'Saruman';
console.log(personaje.nombre); // Saruman

Concatenación de objetos

También puede haber objetos dentro de objetos:


let personaje = {
nombre: 'Gandalf',
puntos: {
   vida: 100,
   mana: 75
},
fuerza: 10
};
console.log(personaje.puntos.mana); // 75

Se llaman a través del punto también. Respentando el orden de família, mana está dentro de puntos que está dentro de personaje:

personaje.puntos.mana

Métodos de los objetos

Si las propiedades eran las características de los objetos (color, edad, nombre, etc), los métodos son las acciones que puede hacer dicho objeto.

Tienen la misma sintaxis que las propiedades. La única diferencia es que lo que sería el valor, tiene que ser una función en lugar de un dato.

Esto nos ayudará a ordenar más el código y no tener que crear funciones externas. Podremos crear una función dentro de un objeto como si fuera una propiedad.

Imaginemos que queremos tener una función que nos de la descripción del estado de nuestro personaje.


function describirPersonaje(personaje) {
   let descripcion = (`${personaje.nombre} tiene ${personaje.puntos.vida} puntos de vida y ${personaje.puntos.mana} puntos de maná. Su nivel de fuerza es ${personaje.fuerza}`);
   return descripcion;
}

Ahora añadiremos esta función como método de nuestro objeto.


let personaje = {
   nombre: 'Gandalf',
   puntos: {
      vida: 100,
      mana: 75
   },
   fuerza: 10,

   describirPersonaje: function() {
      let descripcion = (`${personaje.nombre} tiene ${personaje.puntos.vida} puntos de vida y ${personaje.puntos.mana} puntos de maná. Su nivel de fuerza es ${personaje.fuerza}`);
      return descripcion;
   } 
};

console.log(personaje.describirPersonaje());

// A Gandalf le dan con una flecha 
personaje.puntos.vida -= 20;

// Gandalf consigue una poción de fuerza
personaje.fuerza += 10;

console.log(personaje.describirPersonaje());

Cada vez que quiera que aparezca la descripción del personaje llamo al método de nuestro objeto y no hace falta volver a escribir todo el código otra vez.

Palabra clave this

La palabra clave this representa al objeto dentro del cual se encuentra el método. En el caso anterior, la palabra this, hace referencia al objeto personaje. Vamos a escribir sólo el método describir de antes pero utilizando this.


describirPersonaje: function() {
   let descripcion = (`${this.nombre} tiene ${this.puntos.vida} puntos de vida y ${this.puntos.mana} puntos de maná. Su nivel de fuerza es ${this.fuerza}`);
   return descripcion;
}

¡OJO! ¡VERY IMPORTANT! ¡Las Arrow Functions no aceptan la utilización de this. Así que no pueden ser utilizadas para crear métodos ni para ser constructores!!

console.log(); ➜ ¡Es el método de un objeto!

Ya conocemos lo que hace console.log(); pero ahora podemos ponerle nombre.

El objeto console da acceso a la consola del navegador. Por ejemplo, podemos escribir un mensaje en la consola haciendo uso del método log() del objeto console.

¡Ejercicios!

Objetos 01.- Vamos a hacer un programa simple bancario.

Crea un objeto llamado cliente.
Cada cliente tendrá guardado un "nombre", un "apellido", un "saldo" disponible y el "tipoCliente" que es.
El tipo de cliente lo calcularemos con un método. Y podrá ser de 3 tipos:

Gold si tiene más de 10000€
Silver si tiene entre 5000€ y 10000€
Bronce si tiene menos de 5000€

También crearemos un método que nos de toda la información necesaria del cliente. Un a frase que diga su nombre, apellido, saldo que le queda y el tipo de cliente que es.
Crearemos otro método que servirá para indicar que se ha hecho un ingreso. El método tendrá un parámetro que será el que recibirá la cantidad ingresada.
Haremos lo mismo de antes pero con un reintegro.
Haremos varios console.log diciendo la informacion del cliente, ingresando dinero y retirando dinero y volviendo a imprimir los datos para ver como cambian los tipos de cliente.

Ej. Objetos 01 - Resuelto

   
const cliente = {
   nombre: 'Ivan',
   apellido: 'Luengo',
   saldo: 6000,
   tipoCliente: function() {
      let tipo;
      if (this.saldo >= 10000) {
         tipo = 'Gold';
      } else if (this.saldo < 10000 && this.saldo >= 5000){
         tipo = 'Silver';
      } else {
         tipo = 'Bronce';
      }
      return tipo;
   },
   infoCliente: function() {
      console.log(`El cliente se llama ${this.nombre} ${this.apellido}. Tiene ${this.saldo}€ en su cuenta que es de tipo: ${this.tipoCliente()}.`);
   },
   ingresoDinero: function(ingreso) {
      this.saldo += ingreso;
   },
   reintegroDinero: function (reintegro) {
      this.saldo -= reintegro;
   }
}

console.log(cliente.infoCliente());
cliente.ingresoDinero(4500);
console.log(cliente.infoCliente());
cliente.reintegroDinero(7000);
console.log(cliente.infoCliente());

Programación Orientada a Objetos (POO)

Hasta ahora créabamos objetos uno por uno aunque fueran muy parecidos.

Eso es bastante tedioso si queremos crear muchos objetos. Así que existe una manera más sencilla de hacer eso. Utilizando clases.

Hay varias maneras de hacer esto, como utilizando Object.create() o creando funciones constructoras, pero por ahora voy a explicar la más actual que es creando clases.

Clases JavaScript

Para crear una clase utilizamos la palabra reservada class seguido del nombre de la clase a crear. Por convención utilizamos la primera letra en mayúscula para saber que estamos hablando de una clase.


class Personaje {
   constructor(nombre, vida, fuerza) {

      this.nombre = nombre;
      this.vida = vida;
      this.fuerza = fuerza;
      this.xp = 0;
   }
}

Seguido de la creación de la clase creamos las propiedades que tendrán todos los objetos que creemos a partir de la clase Persona

Para hacerlo utilizamos la palabra reservada constructor y ponemos las variables que queremos crear como parámetros.

Como los valores de estas propiedades se los vamos a pasar como argumentos, tenemos que igualar cada propiedad que va a heredar nuestro objeto con el valor del parámetro de la funcion constructor.

this.propiedad = parametro

Si queremos que todos los objetos que vayamos a crear ya tengan una propiedad con un valor fijo, no la ponemos como parámetro y la añadimos directamente a la lista con this. Como hemos hecho este caso con

this.xp = 0;

Añadir un método

Dentro de la clase pero fuera del constructor añadimos los métodos que queremos que todos los objetos hereden. En este caso solo hace falta poner el nombre de la función y los paréntesis y ya.


class Personaje {
   constructor(nombre, vida, fuerza) {

      this.nombre = nombre;
      this.vida = vida;
      this.fuerza = fuerza;
      this.xp = 0;
   }
   //Método para retornar la descripción del personaje
   describir() {
      let descripcion = `${this.nombre} tiene ${this.vida} puntos de vida, ${this.fuerza} puntos de fuerza y ${this.xp} puntos de experiencia.`;
      return descripcion;
   }
}

Crear un objeto nuevo con NEW

Teniendo nuestro constructor vamos a crear nuevos objetos usando la palabra new


const personaje1 = new Personaje ('Gandalf', 100, 35);
const personaje2 = new Personaje ('Bilbo', 100, 25);

Ahora jugador1 y jugador2 son objetos cuyo prototipo es Persona y heredan tanto las propiedades como los objetos.

Crear una Subclase

A veces vamos a necesitar crear un grupo de objetos que no solo hereden las propiedades y métodos de una clase concreta, sino que queremos que tenga otras propiedades concretas pero que no compartan con los demás objetos. Para ello creamos una subclase.

En nuestro ejemplo, dentro de los personajes podemos claramente diferenciar entre los personajes principales o jugadores y los enemigos. Todos los personajes tendrán nombre, vida y fuerza, pero los jugadores son los que van a tener los puntos de experiencia, y los enemigos no. Y en cambio a lo mejor queremos que solo los enemigos puedan tener una raza.

Lo primero que vamos a hacer es quitar los puntos de experiencia de la clase Personaje.


class Personaje {
   constructor(nombre, vida, fuerza) {

      this.nombre = nombre;
      this.vida = vida;
      this.fuerza = fuerza;
   }
}

Ahora creamos una subclase como si fuera una clase más. La única diferencia es que añadiremos la palabra reservada extends seguido de la clase de donde queremos heredar lo anterior. En nuestro caso Personaje.


class Jugador extends Personaje {
   constructor(nombre, vida, fuerza, magia) {
      super(nombre, vida, fuerza);
      this.magia = magia;     
      this.xp = 0;
   }
}

Puedes ver como también hemos utilizado la palabra reservada super, que lo que viene a decir es "de todas las propiedades que te he escrito en el constructor, cóge las que te pongo aquí de la clase de la que heredo", en nuestro caso, Personaje.
A más a más en nuestro ejemplo hemos añadido la propiedad xp y que igualamos a 0 para que todos los jugadores tengan siempre al empezar 0 puntos de experiencia.
Por último, si quisiéramos crear otra descripción distinta para nuestros personajes, podríamos utilizar la que ya tenemos más arriba en la clase Personaje y "arrastrarla" aquí. Veamos cómo se hace:


class Jugador extends Personaje {
   constructor(nombre, vida, fuerza, magia) {
      super(nombre, vida, fuerza);
      this.magia = magia;     
      this.xp = 0;
   }
   describirPersonaje() {
      let descripcionPersonaje = `, ${this.magia} puntos de mágia y ${this.xp} puntos de experiencia.`
      return super.descripcion + descripcionPersonaje;
   }
}

Aquí no lo vemos, pero antes de nada que quitado de la clase Personaje la parte final del método describir() ya que hablaba de los puntos de experiencia.
Entonces, para poder utilizar métodos de la clase Personaje hemos utilizado super.describir() para que recoja lo que devuelve el método de arriba. Lo único que he hecho luego es concatenarlo con el nuevo texto que quería para los personajes.

Crear otros tipos de objetos con el operador new

El operador new nos permite crear objetos desde cero. Para ello utilizamos el operador new seguido del constructor. Por ejemplo, vamos a crear un nuevo string en forma de objeto.

let texto1 = new String('¡Hola alumno!');

Podemos crear objetos de todo tipo como por ejemplo strings, números, Arrays o fechas


let texto1 = new String('¡Hola alumno!'); // ¡Hola alumno!
let numero1 = new Number(23); // 23
let array1 = new Array(5, 14, 'hola'); // [5, 14, 'hola']
let fecha1 = new Date();

Crear fechas con new Date();

Para crear una fecha que nosotros decidimos utilizamos

new Date(fecha que queremos);

La fecha se puede dar en los siguientes formatos:

Milisegundos➜ Se le da un número de milisegundos desde las doce de la noche de enero de 1970. Algo como 1559531244439
Fecha en forma de cadena de texto ➜ Le damos una fecha como se podría escribir en inglés por ejemplo: "Dec 25, 1995" o otra más completa como: "Mon, 25 Dec 1995 13:30:00 GMT+0430"
año, mes, día (en números) ➜ Se le dan valores numéricos que nos digan el año, mes y dia separados por comas. Por ejemplo: 2015, 0, 15. Se puede completar con los valores por orden de horas, minutos, segundos, milisegundos. ¡OJO! Recuerda que el mes va del 0 al 11 siendo 0 enero y 11 diciembre!

Si entre los paréntesis no ponemos nada, lo que estaremos haciendo es crear una fecha nueva a partir de el mismo momento en que se cargue la página.


let fechaDeHoy = newDate();
console.log(fechaDeHoy); // Mon Jun 03 2019 05:22:50 GMT+0200 (hora de verano de Europa central)

Sacar info de una fecha

A partir de una fecha creada, sea establecida por nosotros o sea la de ahora mismo, podemos sacar información de esa fecha de la siguiente manera.

```
fechaDeHoy.getHours(); // 05
```
➜ Nos devuelve las horas.
```
fechaDeHoy.getMinutes(); // 22
```
➜ Nos devuelve los segundos.
```
fechaDeHoy.getSeconds(); // 50
```
➜ Nos devuelve os segundos.
```
fechaDeHoy.getDay(); // 1
```
➜ Nos devuelve un día de la semana siendo 0 el domingo y 6 el sábado.
```
fechaDeHoy.getDate(); // 3
```
➜ Nos devuelve el día del mes.
```
fechaDeHoy.getMonth(); // 5
```
➜ Nos devuelve el mes del año siendo 0 enero y 11 diciembre.
```
fechaDeHoy.getFullYear(); // 2019
```
➜ Nos devuelve el año.
```
fechaDeHoy.getTime(); // 1559531244439
```
➜ Nos devuelve los milisegundos desde 1970.

Cambiar info de una fecha

Si por el contrario lo que queremos es modificar una parte de una fecha utilizaremos lo siguiente:

```
fechaDeHoy.setTime(); 
```
➜ Le damos milisegundos y nos devuelve una fecha concreta.
```
fechaDeHoy.setFullYear(); 
```
➜ Cambiamos el año de la fecha.
```
fechaDeHoy.setDate(); 
```
➜ Cambiamos el dia del mes de la fecha.
```
fechaDeHoy.setMonth(); 
```
➜ Cambiamos el mes de la fecha.
```
fechaDeHoy.setHours(); 
```
➜ Cambiamos la hora de la fecha. Tambien permite cambiar minutos y segundos.
```
fechaDeHoy.setMinutes(); 
```
➜ Cambiamos los minutos de la fecha.
```
fechaDeHoy.setSeconds(); 
```
➜ Cambiamos los segundos de la fecha.