JavaScript Indoloro

JavaScript sin morir en el intento.

En este tema abracaremos el truculento mundo del JavaScript

Índice de contenidos

Introducción histórica.

Lorem ipsum dolor sit amet consectetur adipisicing elit. Nisi, repellat. Laboriosam, maxime. Dicta laudantium sapiente minus! A ab dolore enim sapiente molestiae explicabo nihil cumque quae quidem! Nemo, necessitatibus suscipit.

Variables

Declaración de variables

En ES6 tenemos nuevos modos de definir variables:


// Variables

var antiguo = "cosa";    // método viejo

let nuevaVariable = true;

const constante = 256;
LET

La declaración con let es igual que con var, pero tienen diferencas.


// LET

let nombre = "Pepe",

    nombre2 = "juan";

A diferencia de var, a let no le podemos re-declarar la variable del mismo modo.


// VAR

var color = "rojo";

var color = "verde";

console.log(color); // devolverá "verde";

// LET

let animal = "perro";

let animal = "gato"

console.log(animal);    // ERROR!!: Uncaught SyntaxError: Identifier 'animal' has already been declared

Lo que podemos hacer, es reasignarle un valor:


let animal = "perro";

animal = "gato"

console.log(animal);    // devuelve gato
CONST

La variable de tipo const tiene un valor constante y no cambia.

Han de usarse para variables cuyo valor sabemos que no va a cambiar.

Debe inicializarse al principio, no se puede inicializar vacía.


let animal;

animal = "loro"

console.log(animal);    // devuelve loro



const profesion;    //  ERROR!!: Uncaught SyntaxError: Missing initializer in const declaration



const transporte = "tren";

console.log(transporte)     // devuelve tren

Tampoco se le puede cambiar el valor asignado:


const ciudad = "Berlin";

ciudad = "Roma";    // ERROR!! Uncaught TypeError: Assignment to constant variable.

En resumen:

VAR es el método antiguo, admite cualquier pillería.

LET la usamos cuando la variable no tiene asignado ningún valor, o su valor va a cambiar.

CONST la usamos cuando sabemos que la variable no va a cambiar de valor.

Tipos de Variables y sus Métdos

En JavaScript tenemos diferentes tipos de datos, o variables. Los datos se los asignamos a las variables, así una variable puede ser de tipo string, numérica, booleana, etc...

String y sus métodos

    let txt ="Javascript";



    // .lenght  => devuelve número de caracteres

    console.log(txt.length);



    // .concat()  para concatenar strings

    console.log(txt.concat(' ','es genial'))



    // .toUpperCase()  --> transforma en mayúsculas

    // .toLowerCase()  --> transforma en minúsculas



    // .indexOf("string")  ==>> devuelve la posición del texto dentro del string

    let mensaje = "Curso de Javascript, HTML y CSS";

    console.log(mensaje.indexOf("Javascript"));

    console.log(mensaje.indexOf("PHP")); // devuelve -1 porque no está





    // .substring(n,n)  -->> Devuelve el 'recorte' de texto entre dos posiciones

    console.log(mensaje.substring(7,16));



    // .slice(n)  -->> 

    console.log("SLICE")

    console.log(mensaje.slice(-5)); // en negativo, empieza del final al principio

    console.log(mensaje.slice(7,16)); // así es igual que substring()



    // .split()  -->> trozear string; devuelve un Array

    console.log("SPLIT: ");

    console.log(mensaje.split(" "));



    // .replace("str1", "str2"); reemplaza una cadena por otra

    console.log("REPLACE: ")

    console.log(mensaje.replace("CSS","PHP"));





    // .includes("str")  -->> comprueba si existe una cadena dentro del string. Devuelve true o false

    console.log(mensaje.includes("CSS"));



    // .repeat(n)  --> repite n veces un string

    console.log("REPEAT: ")

    console.log(mensaje.repeat(2));



    // String Literal (o template literal)

    let nombre = "pepe";

    let edad = 66;

    console.log(`Bienvenido ${nombre} de ${edad} años`);



    // Template Literal (Ejemplo)

    const prod1 = "Pizza",

        precio1 = 30,

        prod2 = "Hamburguesa",

        precio2 = 40;



    // Versión vieja

    let html;

    html = '<ul>'+

            '<li>Orden: '+prod1+'</li>'+

            '<li>Precio: '+precio1+'</li>'+

            '<li>Orden: '+prod2+'</li>'+

            '<li>Precio: '+precio2+'</li>'+

            '<li>Total: ' +(precio1+precio2)+'</li>'+

            '</ul>';

    document.getElementById("app").innerHTML = html;



    // VERsioN MODERNA

    let html2;

    html2 = `

        <ul>

            <li>Orden: ${prod1} </li>

            <li>Precio: ${precio1} </li>

            <li>Orden: ${prod2} </li>

            <li>Precio: ${precio2} </li>

            <li>Total: ${total(precio1,precio2)} </li>

        </ul>

    `;



    function total(precio1,precio2) {

        return precio1 + precio2;

    }





    document.getElementById("app").innerHTML = html;
Number y sus métodos

    const number1 = 30,

        number2 = 20,

        number3 = 20.20,

        number4 = .1020,

        number5 = -43;





    let resultado;



    // suma

    resultado = number1 + number2;

    // resta

    resultado = number1 + number2;

    // multiplicación

    resultado = number1 * number2;

    // division 

    resultado = number1 / number2;

    // módulo

    resultado = number1 % number2;





    // PI

    resultado = Math.PI;



    // redondeo

    resultado = Math.round(2.5)	// da 3

    resultado = Math.round(2.4)	// da 2



    // redondeo hacia Arriba

    resultado = Math.ceil(2.1) // da 3



    // redondeo hacia abajo

    resultado = Math.floor(2.999) // da 2



    // Raiz Cuadrada

    resultado = Math.sqrt(25);



    // Número absoluto

    resultado = Math.abs(-34);



    // Exponenciales

    resultado = Math.pow(2,8);



    // Mínimo

    resultado = Math.min(3,654,12,64,123,76,12,-65,9,0.45);



    // Maximo

    resultado = Math.max(3,654,12,64,123,76,12,-65,9,0.45);



    // Aleatria

    resultado = Math.random();



    // toFixed()  Elegir decimales

    let numeroLargo = 242645532432.765763223

    resultado = numeroLargo.toFixed();	// redondea

    resultado = numeroLargo.toFixed(4);	// lo corta hasta 4 decimales





    console.log(resultado);





    // PASAR STRING A NUMBER



    const n1 = "50",

        n2 = 10,

        n3 = "tres";



    console.log(n1 + n2);	// 5010

    console.log(typeof(n1 + n2));	// String



    console.log(Number(n1) + n2);	// 60

    console.log(parseInt(n1) + n2);	// 60



    // ¡¡Curiosidad!!

    console.log(n1 - n2);

    console.log(typeof(n1 - n2));	// number





    // parseFloat y parseInt

    let dato = 45;

        dato = parseInt('100');

        dato = parseFloat("100.2040");

    console.log(dato);





    // CONVERTIR NÚMERO A STRING

        // ejemplo práctico: nº de caracterers de un código postal

    let codigoPostal = 28080;

        // console.log(codigoPostal.lenght)	// Undefined (es un número aun)

    codigoPostal = String(codigoPostal);

    console.log(codigoPostal.length);	// 5, ya es un string

        // .toSting()  (método 2)

    let cp2 = 90210;

    cp2 = cp2.toString();

    console.log(typeof cp2);
Array y sus métodos

    // ARRAYS

    const numeros = [10,20,30,40,50];

    console.log(numeros);



    const meses = new Array("enero","febrero","marzo","abril");



    const mix = new Array(342,"Pere",true,undefined,"cas44",null);



    // .length  nº elementos

    meses.length // 4



    // comprobar si es array

    console.log(Array.isArray(meses));



    // .push()  AÑADE AL FINAL

    meses.push("mayo");



    // .unshift()  AÑADE AL PRINCIPIO

    meses.unshift("mes 0");



    // ELIMINAR ELEMENTO

    meses.pop();  // ELIMINA EL ÚLTIMO ELEMENTO

    meses.shift() // ELIMINA EL PRIMER ELEMENTO

    meses.splice(2,1)	// splice(índice,cantidad)  --> desde la posición "indice" quita "cantidad" elementos





    // INVERTIR ARRAY

    meses.reverse();



    // Encontrar un elemento en el array

    meses.indexOf("marzo");	// 2



    // unir 2 arrays

    const arr1 = [1,2,3],

        arr2 = [7,8,9];

    console.log(arr1.concat(arr2));



    console.log(meses);



    // ORDENAR ARRAYS

    const frutas = ["platano","manzan","zanahoria","pera","kiwi","fresa"];

    frutas.sort();

    console.log(frutas);	// -->> Orden alfabñetico



    const numeros22 = [1,543,23,75,22,76,346,987,12345,46];

    numeros22.sort();

    console.log(numeros22);	// Nos da el orden de MS-Dos



    numeros22.sort(function(x,y){

        return x - y;

    });

    console.log(numeros22);	// Nos da el orden bueno ascendente



    numeros22.sort(function(x,y){

        return y - x;

    });

    console.log(numeros22);	// Nos da el orden bueno descendente





    // NOTA

    /*

        Un Array definido con const:  

            const numeros = [1,2,3];

        NO PUEDE REDEFINIRSE:

            numeros = [4,6,7] --> DA ERROR



        Sin embargo, se puede modificar con los métodos vistos antes, o reasignando cada elemento

            numeros[0] = 55;

    */
Objeto y sus métodos

    const persona = {

        nombre: "Pablo",

        edad: 38,

        profesion: "Front-End",

        email: "pablofveiga@gmail.com",

        lenguajes: ["CSS","HTML","JAVASCRIPT"],

        hogar: {

            ciudad: "Aviles",

            casa: "Piso",

            mascota: false

        },

        nacimiento: function(){

            // return new Date().getFullYear() - persona.edad;	// MAL --> se usa this.

            return new Date().getFullYear() - this.edad;

        }

    }



    persona.lenguajes.push("ES6");



    console.log(persona);

    console.log(persona.nombre);

    console.log(persona.hogar.casa);

    console.log(persona.nacimiento());



    // OBJECT LITERAL

    const cliente = {

        nombre : "Pablo",

        saldo: 600,

        tipoCliente : function() {

                let tipo;

                if ( this.saldo > 1000 ) {

                    tipo = "Gold";

                } else if (this.saldo > 500) {

                    tipo = "Platinum"

                }

                else {

                    tipo = "Normal";

                }

                return tipo;

            }

    }



    console.log(cliente.tipoCliente());



    // MÉTODO ALTERNATIVO (MEJOR)

    function Cliente(nombre,saldo) {

        this.nombre = nombre;

        this.saldo = saldo;



        this.tipoCliente = function() {

            let tipo;

            if ( this.saldo > 1000 ) {

                tipo = "Gold";

            } else if (this.saldo > 500) {

                tipo = "Platinum"

            }

            else {

                tipo = "Normal";

            }

            return tipo;

        }

    }



    const persona = new Cliente("Pedro",3450);

    console.log(persona);





    // STRING

    const nombre1 = "Pedro";

    const nombre2 = new String("Pedro");



    console.log(typeof nombre1);    // devuelve String

    console.log(typeof nombre2);    // devuelve Object

    console.log(nombre2);    // devuelve el Objecto con su prototipos y métodos, etc...



    // Comparación:

    if (nombre1 == nombre2) {

        console.log(`La comparación == funciona`)

    } else { console.log("No son iguales ==")}  // falso



    if (nombre1 === nombre2) {

        console.log(`La comparación === funciona`)  // falso

    } else { console.log("La comparación estricta === no funciona")}    





    // NUMEROS

    const numero1 = 20;

    const numero2 = new Number(20);    

    console.log(numero1);

    console.log(numero2);   // El _proto_ hereda un montón de métodos



    // BOOLEANOS

    const boolean1 = true;

    const boolean2 = new Boolean(true);

    console.log(boolean1);

    console.log(boolean2);



    // FUNCIONES

    const funcion1 = function(a,b) { return a + b; }

    const funcion2 = new Function("a","b", "return a+b");

    console.log(funcion1(2,3));

    console.log(funcion2(2,3));

    console.log(typeof funcion1);

    console.log(typeof funcion2);



    // OBJETOS

    const objeto1 = { nombre: "pepe"}

    const objeto2 = new Object({nombre: "pepe"});

    console.log(objeto1);

    console.log(objeto2);



    // ARRAYS

    const array1 = [1,2,3,4];

    const array2 = new Array(1,2,3,4);

    console.log(array1);

    console.log(array2);

Scope de las variables

Lorem, ipsum dolor sit amet consectetur adipisicing elit. Ipsa eius repellat fugiat, sunt odio exercitationem magni minus ab quaerat quia sequi id ut aspernatur quod incidunt esse dicta quo maiores?

Asignación de variables por Destructuring

Lorem, ipsum dolor sit amet consectetur adipisicing elit. Ipsa eius repellat fugiat, sunt odio exercitationem magni minus ab quaerat quia sequi id ut aspernatur quod incidunt esse dicta quo maiores?

Funciones

Lorem, ipsum dolor sit amet consectetur adipisicing elit. Ipsa eius repellat fugiat, sunt odio exercitationem magni minus ab quaerat quia sequi id ut aspernatur quod incidunt esse dicta quo maiores?


// FUNCTION DECLARATION

function saludar(nombre) {



    // DAR VALOR POR DEFECTO: VERSION VIEJA

    if (typeof nombre === "undefined" ) {

        nombre = "Pablo";

    }



    return `Hola ${nombre}`;

}



let saludo;

saludo = saludar();

console.log(saludo);





// NUEVA FORMA DE INICIALIZAR PARÁMETROS

function saludar2(nombre = "Visitante") {

    return `Hola de nuevo ${nombre}`;

}

let saludo2;

saludo2 = saludar2();

console.log(saludo2);





// FUNCTION EXPRESSION

    // Es definirla como una variable

const suma = function(a=3, b=4){

    return a + b;

}

console.log(suma(3,5));

console.log(suma(5));







// FUNCIONES "IIFE" : Se declaran e invocan inmediatamete

(function(){

    console.log("Creando un IFFE");

})();



(function(tecnologia){

    console.log(`Aprendiendo ${tecnologia}`);

})("Javascript");





// MÉTODOS DE PROPIEDADES

    // Cuando una función se pone dentro de un objeto. Dichas funciones se conocen como métodos

const musica =  {

    reproducir: function(id){

        console.log(`reproduciendo Música con id ${id}`);

    },

    pausa: function(){

        console.log("Pausando Música");

    }

}

musica.reproducir(45);

musica.pausa();

    // Los métodos también pueden guardarse/crearse fuera del objeto

musica.borrar = function(id){

    console.log(`Borrando cancion con id ${id}`);

}

musica.borrar(2);

console.log(musica);	// el método borrar se ha añadido al objeto

                

Manejo de errores con Try Catch

Lorem, ipsum dolor sit amet consectetur adipisicing elit. Ipsa eius repellat fugiat, sunt odio exercitationem magni minus ab quaerat quia sequi id ut aspernatur quod incidunt esse dicta quo maiores?


// funcion que no existe

try {

    algo();

} catch (error) {

    console.log("error");

} finally {

    console.log("Continua, no hay problema. Esto se ejecuta siempre");

}



function obtenerClientes() {

    console.log(`Descargando......`);

    setTimeout(function(){

        console.log("Finalizado");

    },1500)

}



obtenerClientes();

Objeto Date()

Lorem, ipsum dolor sit amet consectetur adipisicing elit. Ipsa eius repellat fugiat, sunt odio exercitationem magni minus ab quaerat quia sequi id ut aspernatur quod incidunt esse dicta quo maiores?


// Fecha entera

const diaHoy = new Date();



// Fecha específica, Navidad 2017

let navidad2017 = new Date('12-25-2017');



let valor;

// Año

year = diaHoy.getFullYear();

// Mes

mes = diaHoy.getMonth();

// Dia de la semana

diaSemana = diaHoy.getDay();

// Dia del mes

diaMes = diaHoy.getDate();

// Hora

hora = diaHoy.getHours();

// Milisegundos desde 1970

ticks = diaHoy.getTime();



// OJO!!!

// Observa como se usa el get...

// Pues también hay set.

let superFecha = diaHoy.getFullYear();

superFecha = diaHoy.setFullYear(1492);

superFecha = diaHoy.getFullYear();

console.log(`la superfecha es ${superFecha}`);





console.log(diaHoy);

console.log(navidad2017);

console.log(`año: ${year}`);

console.log(`mes: ${mes}`);

console.log(`dia de la semana: ${diaSemana}`);

console.log(`dia del mes: ${diaMes}`);

console.log(`hora: ${hora}`);

console.log(`ticks: ${ticks}`);

Estructuras de Control

Lorem, ipsum dolor sit amet consectetur adipisicing elit. Ipsa eius repellat fugiat, sunt odio exercitationem magni minus ab quaerat quia sequi id ut aspernatur quod incidunt esse dicta quo maiores?

IF... ELSE

Lorem ipsum dolor, sit amet consectetur adipisicing elit. Beatae, quam tempore dolore, quo, assumenda officiis fugit inventore laborum sunt consectetur deleniti? Hic atque maxime odio! Inventore earum aliquid fuga voluptates.


let _time = new Date();

hora = _time.getHours();



if(hora <= 14) {

    console.log(`Buenos días, son las ${hora}`);

} else if (hora >=14) {

    console.log(`Buenas tardes, son las ${hora}`);

} else {

    console.log(`Buenas noches, son las ${hora}`);

}

Operador ternario


// Operador Ternario

const logeado = true;

    // version mala

logeado === true ? console.log("estás online") : console.log("estas offline");

    // version buena

console.log(logeado === true ? "estás online": "estas offline" );

Switch

Lorem ipsum dolor, sit amet consectetur adipisicing elit. Beatae, quam tempore dolore, quo, assumenda officiis fugit inventore laborum sunt consectetur deleniti? Hic atque maxime odio! Inventore earum aliquid fuga voluptates.


// SWITCH

    // el case hace una comparación del tipo "==="

switch(this.marca) {

case "1": 

    cantidad = base * 1.15;

    break;

case "2": 

    cantidad = base * 1.05;

    break;

case "3": 

    cantidad = base * 1.35;

    break;           

default:

    console.log("No cumple ninguna condición anterior")

    break;

}

For

Lorem ipsum dolor, sit amet consectetur adipisicing elit. Beatae, quam tempore dolore, quo, assumenda officiis fugit inventore laborum sunt consectetur deleniti? Hic atque maxime odio! Inventore earum aliquid fuga voluptates.


// FOR

for( let i = 0; i<10; i++) {

    console.log(`Hola por ${i} vez`);

}

// ## VARIAR EL FLUJO CON "continue" Y "break"

    // SALTAR EN EL BUCLE (continue)

for(let i = 0; i<10; i++) {

    if(i==5) {

        console.log("voy en el 5");

        continue;   // Esto hace que se vuelva al FOR y se salte las órdenes que tiene debajo (el console.log)

    }

    console.log(i);

}

    // DETENER UN FOR (break)

for(let i = 0; i<10; i++) {

    if(i==5) {

        console.log("en 4 rompo el bucle");

        break;

    }

    console.log(i);

}

// EJEMPLO NUMERO PAR/IMPAR

for(let i = 0; i<10; i++) {

    if(i%2==0) {

        console.log(`${i} es un numero par`);

    } else {

        console.log(`${i} es un numero impar`);

    }

    

}

While y Do While

Lorem ipsum dolor, sit amet consectetur adipisicing elit. Beatae, quam tempore dolore, quo, assumenda officiis fugit inventore laborum sunt consectetur deleniti? Hic atque maxime odio! Inventore earum aliquid fuga voluptates.


// WHILE

let i = 0;

while (i <10) {

    if(i===5) {

        console.log("Sale cinco en letra, y me salto lo de debajo para reiniciar el while");

        i++;

        continue;   // TAMBIEN PODEMOS USAR continue Y break        

    }

    console.log(i);

    i++;

}



// DO WHILE

    // Ejecuta el código al menos una vez, independientemente de si la condición se cumple

let u = 120;

do {

    console.log(`Do while ${u}`);

    u++;

} while(u<10);

forEach

Lorem ipsum dolor, sit amet consectetur adipisicing elit. Beatae, quam tempore dolore, quo, assumenda officiis fugit inventore laborum sunt consectetur deleniti? Hic atque maxime odio! Inventore earum aliquid fuga voluptates.


// FOREACH

const tareasPendientes = ['Tarea','Comer','Proyecto','Cenar'];

tareasPendientes.forEach(function(tareaPendiente) {

    console.log(`${tareaPendiente}`);

});



    // podemos pasar parámetros, como "index" para obtener el índice

tareas.forEach(function(tareaPendiente, index){

    console.log(`${index}:  ${tareaPendiente}`);

});

MAP

Con MAP podemos recorrer un array.


// MAP para recorrer arrays

const carrito = [

    {id: 1, producto: "coche"},

    {id: 2, producto: "libro"},

    {id: 3, producto: "vaca"},

    {id: 4, producto: "misil"}

];



const nombreProducto = carrito.map(function(carrito){

    return carrito.producto;

})



console.log(nombreProducto);

for... in

Podemos mostrar un objeto


// FOR IN

const automovil = {

    marca: "renault",

    modelo: "cinco",

    anio: 1987

}

for (let auto in automovil) {

    console.log(`${auto} : ${automovil[auto]}`);    // imprime la clave y el valor

}

Objeto Window

El window object es nuestra ventana de navegación.

Contiene mucha información: idioma, dimensiones, navegador, etc...

Por ejemplo, el console.log forma parte del window object; puedes escribir console.log("hola") ó window.console.log("hola")

Algunos métodos que no vamos a ver por cansinos son:

  • alert
  • prompt
  • confirm

Métodos para dimensiones:


// OBJETO WINDOW: MÉTODOS ÚTILES

let altura = window.outerHeight;    // Altura de la ventana (incluye la consola y toda la parafernalia del navegador)

let anchura = window.outerWidth;    // Anchura de la ventana (con la interfaz del navegador) 



let altura = window.outerHeight;    // Altura de la ventana (sin la interfaz del navegador)

let anchura = window.outerWidth;    // Anchura de la ventana (sin la interfaz del navegador) 



let ubicacion = window.location         // url completa

let ubicacion2 = window.location.host    // se pueden pedir diferentes parámetros del location

window.location.href = "http://www.google.com"         // redireccionar



window.history.go(-3);  // volver atras en el navegador

window.navigator.language;  // idioma

Scope

El scope de las variables es de vital importancia.

La introducción de "let" y "const" han facilitado las cosas.


// SCOPE DE LAS VARIABLES

var a = "a";

let b = "b";

const c = "c";



// Scope de la función

function funcionScope() {

    var a = "A";

    let b = "B";

    const c = "C";

    console.log("FUNCION: " + a,b,c);   // devuelve: FUNCION: A B C

}



// Scope de Bloque

if(true) {

    var a = "AA";

    let b = "BB";

    const c = "CC";

    console.log("BLOQUE: " + a,b,c);    // devuelve: BLOQUE: AA BB CC

}



console.log("GLOBALES: " + a,b,c);  // devuelve: GLOBALES: AA b c
El Doom fue un juegazo, el DOM es otra cosa

DOM: Document Object Model

document object model

// DOM

let elemento;

elemento = document;            // Todo todito todo

elemento = document.all;        // Devuelve un HTMLAllCollection

elemento = document.all[10];    // Devuelve un elemento en concreto

elemento = document.head;       // Devuelve el elemento <head>

elemento = document.body;       // Devuelve el cuerpo del documento

elemento = document.domain;     // Devuelve el dominio

elemento = document.URL;        // Devuelve la url

elemento = document.characterSet    // Nos devuelve la codificación de caracterers (UTF-8, ISO-...)



elemento = document.forms       // Devuelve todos los formularios del documento

elemento = document.forms[0]    // Devuelve un formulario en concreto

elemento = document.forms[0].id    // Devuelve la id de ese formulario en concreto

elemento = document.forms[0].className  // Nos devuelve las clases  (modificando con className podemos afectar a todas las clases:  className = ""; borra todas las clases)

elemento = document.forms[0].classList  // Si hay muchas clases, nos devuelve un "DOMTkenList"  (añadir o quitar con classList no afecta a las otras clases: classList.add("foo") )

elemento = document.forms[0].classList[0]  // Accede a una clase en concreto



elemento = document.images;     // Devuelve las imágenes del documento (HTMLCollection) , con sus clases y atributos

elemento = document.images[3];  // Devuelve una imagen en concreto

elemento = document.images[2].src;  // Devuelve un atributo (src) de la imagen en concreto (devuelve el src con el dominio y todo)

elemento = document.images[2].getAttribute("src");  // Devuelve el atributo (src) de la imagen en concreto sin el dominio



elemento = document.scripts     // Devuelve los scripts del documento



console.log(elemento);

Convertir un HTMLCollection en un Array


// HTMLCollection --> Array

let imagenes = document.images;

let imagenesArray = Array.from(imagenes);



// Vamos a listarlas

imagenesArray.forEach(function(imagen) {

    console.log(imagen);

})



Seleccionar Elementos


// Seleccionar Elementos

// getElementById

let elemento = document.getElementById("cabecera");

elemento.id;    // devuelve la ID

elemento.className;    // devuelve la clase

elemento.textContent;    // devuelve el texto que tenga

elemento.innerText;    // también devuelve el texto que tenga

elemento.innerText = "Nuevo texto";    // modifica el texto que tenga

elemento.style.color = "#fc0";  // cambia propiedades css



// getElementsbyClassName

let enlaces = getElementsbyClassName("enlace"); // nos devuelve todos los elementos de clase "enlace" en HTMLCollection



// querySelector

const encabezado = document.querySelector("#encabezado");

const encabezado = document.querySelector("#principal a:first-child");  // podemos usar todo tipo de selectores CSS

let imagen = document.querySelector("img");     // si hay varias imágenes, nos devuelve la primera



// se pueden usar conjuntamente:

let listaEnlaces = document.getElementById("principal").querySelector(".navegacion").getElementsbyClassName("enlace");



// getElementByTagName   (llamar a una <etiqueta> HTML)

let links = document.getElementsByTagName("a");

links[23].color = "#fcc";

let enlaces = Array.from(links);

enlaces.forEach(function(enlace){

    console.log(enlace.textContent);

})



// querySelectorAll

const enlaces = document.querySelectorAll("#principal .enlace");

console.log(enlaces);   // Devuelve un NodeList con los enlaces

enlaces[1].style.color = "red";

Traversing


<!-- CÓDIGO HTML -->

<nav id="principal" class="menu">

    <a class="enlace" href="#">Enlace 1</a>

    <a class="enlace" href="#">Enlace 2</a>

    <a class="enlace" href="#">Enlace 3</a>

    <a class="enlace" href="#">Enlace 4</a>

    <a class="enlace" href="#">Enlace 5</a>

</nav>

// CÓDIGO JAVASCRIPT

const navegacion = document.querySelector("#principal");



navegacion.childNodes;  // devuelve los nodos. Incluye incluso hasta los espacios entre etiquetas

navegacion.children;    // No devuelve los espacios en blanco, como sí lo hace childNodes

navegacion.children[0].nodeName     // devuelve el tipo de nodo  (nos diría "A" o "NAV", que es un enlace <a> o <nav> )

navegacion.children[0].nodeType     // devuelve el tipo de nodo:

//  1 = Elementos

//  2 = Atributos

//  3 = Text Node

//  8 = Comentarios

//  9 = Documentos

// 10 = Doctype



// Se pueden anidar .children varias veces, y acceder a propiedades

navegacion.children[1].children[0].textContent = "nuevo texto";



// Acceder al primer y último elemento:

navegacion.lastElementChild

navegacion.firstElementChild



// Contar número de hijos

navegacion.childElementCount;  // Devuelve un número



const enlaces = document.querySelectorAll(".enlace");

enlaces[0];     // primer enlace

enlaces[0].parentNode;     // sube un nivel --> va al nav#principal

enlaces[0].parentElement;     // RECOMENDADO: igualmente sube un nivel --> va al nav#principal

enlaces[0].parentElement.parentElement;     // Sube otro nivel por encima del nav  



const cursos = document.querySelectorAll(".card");

cursos[0];

cursos[0].parentElemnt.parentElemnt.parentElemnt.children[0].textContent = "Hola";



// volviendo a los enlaces:

const enlaces = document.querySelectorAll(".link");

enlaces[4].previousSibiling;    // devuelve el espacio en blanco (nodo)

enlaces[4].previousElementSibiling  // devuelve el elemento previo al mismo nivel

enlaces[4].previousElementSibiling.previousElementSibiling  // devuelve el elemento previo al previo al mismo nivel

enlaces[0].nextElementSibiling  // el elemento siguiente


// CREAR Elementos

const enlace = document.createElement("a");     // Creamos un elemento <a>

enlace.className = "enlace";                    // le añadimos una clase

        enlace.classList.add("enlace");                 // le añadimos una clase (mmétodo 2)

enlace.id = "nuevoId";                          // añador ID;

enlace.setAttribute("href","#");                // Añadir atributos

enlace.textContent = "Nuevo Enlace";            // Añadir texto

enlace.appendChild(document.createTextNode("Nuevo Enlace"));    // Añadir nodo de texto (método 2)



// Agregar al HTML

document.querySelector(".contenedor").appendChild(enlace);



// REEMPLAZAR UN ELEMENTO POR OTRO

const nuevoEncabezado = document.createElement("h2");   // creo elemento

nuevoEncabezado.id = "encabezado";  // le doy una id

nuevoEncabezado.appendChild(document.createTextNode("Este es el nuevo encabezado"));    // añadimos un nodo de texto

    // reemplazando

const anterior = document.querySelector("#encabezado");

const elementoPadre = document.querySelector("#lista-cursos");

elementoPadre.replaceChild(nuevoEncabezado, anterior);



// ELIMINAR ELEMENTOS DEL DOM

const enlaces = document.querySelectorAll(".enlace");

const navegacion = document.querySelector("nav#principal");



enlaces[0].remove();    // Eliminamos el primer elemento desde sí mismo

navegacion.removeChild(enlaces[0]);     // Eliminar desde el padre



// OBTENER UNA CLASE css

const primerLi = document.querySelector(".enlace");

let elemento;

elemento = primerLi.className;          // devuelve la primera clase

elemento = primerLi.classList;          // devuelve todas las clases

elemento = primerLi.classList.add("nueva-clase");       // añade una clase

elemento = primerLi.classList.remove("nueva-clase");    // elimina una clase





// LEER Atributos

primerLi.getAttribute("href");      // nos da el enlace



// AÑADIR/MODIFICAR ATRIBUTOS

primerLi.setAttribute("href","#");      // especificamos el enlace a #



// ELIMINAR ATRIBUTOS

primerLi.removeAttribute("data-id");



// COMPROBAR SI TIENE ATRIBUTOS

primerLi.hasAttribute("data-id");   // boolean

Event Listeners


// EVENT LISTENERS

document.querySelector("#submit-buscador").addEventListener("click", function(e){

    e.preventDefault();         // Previene el submit de su comportamiento

    alert(`has echo click, 

            pero no habrá submit

            `);                                   

});



// Se puede hacer de otro modo:

document.querySelector("#submit-buscador").addEventListener("click", pulsarBoton);

function pulsarBoton(e) {

    e.preventDefault();

    console.log("Desde la función ejecutarBoton");





    // Veamos más sobre ese "e" (evento)

    let elemento = e;



    console.log(elemento);  // Devuelve un MouseEvent con mucha información

    elemento.type;      // que tipo de evento (click en este caso)

    elemento.target     // elemento sobre el que se ha hecho click

    elemento.target.id     

    elemento.target.innerText;     

    elemento.target.innerText = "texto cambiado";     

}



// ###################################################

// MOUSE EVENT Listeners

let caja = document.querySelector("#buscador");

function obtenerEvento(e) {

    console.log(e.type);

}

// CLICK

caja.addEventListener("click",obtenerEvento);

// DOBLE CLICK

caja.addEventListener("dblclick",obtenerEvento);

// Mouse Enter

caja.addEventListener("mouseenter",obtenerEvento);

// Mouse Leave

caja.addEventListener("mouseleave",obtenerEvento);

// Mouse Over

caja.addEventListener("mouseover",obtenerEvento);

// Mouse Out (similar a mouseleave)

caja.addEventListener("mouseout",obtenerEvento);

// Mouse Down

caja.addEventListener("mousedown",obtenerEvento);

// Mouse Up

caja.addEventListener("mouseup",obtenerEvento);



// ###################################################

// EVENT LISTENERS PARA INPUTS

let el = document.getElementByTagName("input");

function obtenerEvento(e) {

    console.log(el.value);

    console.log(e.type);

}

// KEYDOWN

el.addEventListener("keydown",obtenerEvento);   // pulsar una tecla

// KEYUP

el.addEventListener("keyup",obtenerEvento);   // dejar de presionar (soltar) una tecla

// KEYPRESS

el.addEventListener("keypress",obtenerEvento);   // tecla presionada

// FOCUS

el.addEventListener("focus",obtenerEvento);   // entrar en el foco

// BLUR

el.addEventListener("blur",obtenerEvento);   // perder el foco (pulsar fuera despues de estar en un input); típico en validación

// CUT

el.addEventListener("cut",obtenerEvento);   // cortar texto

// COPY

el.addEventListener("copy",obtenerEvento);   // copiar texto

// PASTE

el.addEventListener("paste",obtenerEvento);   // pegar texto

// INPUT

el.addEventListener("input",obtenerEvento);   // abarca todos los event listeners anteriores

// CHANGE

el.addEventListener("change",obtenerEvento);   // avisa cuando se cambia en un elemento <select>

Event Bubbling


<div class="contenedor">

    <div class="caja caja1">

        ESTA ES LA CAJA SUPERIOR

        <div class="caja caja2">

            ésta está dentro



            <div class="caja caja3">

                ésta es la más profunda

            </div>

        </div>

    </div>

</div>

let caja1 = document.querySelector(".caja1");

let caja2 = document.querySelector(".caja2");

let caja3 = document.querySelector(".caja3");



caja1.addEventListener("click",mostrarEvento);

caja2.addEventListener("click",mostrarEvento);

caja3.addEventListener("click",mostrarEvento);



// FORMA EN LA QUE SE SOLAPAN

function mostrarEvento(e){

    let cajaClickada = e.target.className;

    console.log(cajaClickada);

    console.log(e.type);

}



// FORMA BUENA!!

function mostrarEvento(e){

    e.stopPropagation();

    let cajaClickada = e.target.className;

    console.log(cajaClickada);

    console.log(e.type);

}



// DELEGATION

document.body.addEventListener("click",eliminarElemento);

function eliminarElemento(e) {

    e.preventDefault();

    // Filtramos (delegamos) las acciones según el elemnto sobre el que se ha hecho click

    if(e.target.classList.contains("borrar-curso")) {

        console.log("borrar");

    } else {

        console.log("No borrar");

    }

    if(e.target.classList.contains("agregar-curso")) {

        console.log("Curso Agregado");

    }

}

LocalStorage y SessionStorage


// LocalStorage

// LocalStorage persiste después de cerrar el navegador

localStorage.setItem("nombre","Pablo");



// Alñadir a Sesion Storage: No persiste al cerrar el navegador

sessionStorage.setItem("edad",38);



// Borrar algo del local storage

localStorage.removeItem("nombre");



// Obtener valor

localStorage.setItem("color","azul");   //setItem agrega o modifica un valor

localStorage.getItem("color")



// Borrar todo el localstorage

localStorage.clear();

Objetos


    // Objetos



Clases


    // Clases



Ajax y XMLHTTPRequest


    // Ajax y XMLHTTPRequest



JavaScript Asíncrono o Async JS


    // JavaScript Asíncrono o Async JS



Fetch API


    // Fetch API



Arrow Functions


    // Arrow Functions



Async Await


    // Async Await




OTRO!! .. Notaciones (reeditar en el futuro)


var primerNombre;   // Camelcase

var primer_nombre;  // Underscore

var PrimerNombre;   // Pascal Case

var primernombre;   // dirty