Mostrando entradas con la etiqueta DOM. Mostrar todas las entradas
Mostrando entradas con la etiqueta DOM. Mostrar todas las entradas

miércoles, 16 de septiembre de 2020

Lista de la compra usando localStorage en JS

Usando el método localStorage de JavaScript podemos guardar datos en el propio navegador. Esto nos permite guardar los datos que queramos y que al cerrar el navegador o incluso al reiniciar el PC podamos seguir accediendo a los datos sin problema. 

El código en GitHub: https://github.com/magnitopic/edujs/tree/master/ListaCompraJS

Mira el codigo ejecutandose en relp.it: https://listacomprajs.valoro.repl.co/

index.html

 <!DOCTYPE html>  
 <html lang="en">  
 <head>  
   <meta charset="UTF-8">  
   <meta name="viewport" content="width=device-width, initial-scale=1.0">  
   <title>Main HTML</title>  
 </head>  
 <body>  
   <h1>Lista de la compra</h1>  
   <p>Añadir item a la lista</p>  
   <input type="text" id="entrada">  
   <button onclick="anadir()">Añadir</button>  
   <div id="resultado">  
     <ul id="lista-compra"></ul>  
   </div>  
   <script src="script.js"></script>  
 </body>  
 </html>  

script.js
 'use strict'  
 var contador= 0;  
 function anadir(){  
   var x = document.getElementById("entrada").value;  
   if(x.length <= 0){  
   }else{  
     localStorage.setItem(x,x);  
     location.reload();   
   }  
 }  
 var ul = document.getElementById('lista-compra');  
   for(var i in localStorage){  
     if(typeof localStorage[i] =='string'){  
       var li= document.createElement("li");  
       li.append(localStorage[i]);  
       ul.append(li);  
     }  
   }  

domingo, 29 de septiembre de 2019

JavaScript manejando el DOM

Este artículo forma parte de una serie que trata sobre el DOM (Document Object Model) y su manejo desde JavaScript.
  1. JavaScript manejo del DOM
  2. Manejar el DOM en JavaScript
  3. Cambiar color usando el DOM en JavaScript
  4. JavaScript manejando el DOM por sus etiquetas
  5. JavaScript manejando el DOM con las clases
  6. JavaScript manejando el DOM
En https://www.w3schools.com podemos ver la página
y dentro de ella el ejemplo

Basándonos en esta idea vamos a plantear un nuevo caso práctico. Disponemos de una lista con tres elementos que deseamos cambiar.

La lista original es la siguiente.



Después de pulsar el botón obtenemos una nueva lista.


El código funcionando podemos verlo en el siguiente enlace.

HTML

Creamos una lista con tres elementos li.

 <!DOCTYPE html>  
 <html>  
  <head>  
   <meta charset="utf-8">  
   <meta name="viewport" content="width=device-width">  
   <title>repl.it</title>  
  </head>  
  <body>  
   <ul>  
    <li>uno</li>  
    <li>dos</li>  
    <li>tres</li>  
   </ul>  
   <p>Presiona el botón para cambiar el texto de los elementos de la lista.</p>  
   <button onclick="myFunction()">Pruébalo</button>  
   <script type="text/javascript" src="script.js"></script>  
  </body>  
 </html>  

JavaScript

Método 1

Creamos la variable list que contiene un HTMLCollection que se forma con los elementos li del DOM.
Construimos un bucle for clásico donde gracias a item(i) podemos recorrer todos los elementos li y modificarlos. Podríamos haber escrito

list.item(i).innerHTML=i+1;

pero hemos preferido incluir algo de código HTML para que aparezcan en cursiva los números 1, 2 y 3.

 //Método 1  
 function myFunction() {  
  var list = document.getElementsByTagName("LI");  
  for (var i=0;i<list.length;i++){  
      list.item(i).innerHTML='<i>'+parseInt(i+1)+'</i>';  
  }  
 }  

Método 2

En este caso hemos contruido el bucle con la estructura for of.

 //Método 2  
 function myFunction() {  
  var list = document.getElementsByTagName("LI");  
  var i=1;  
  for (var elemento of list){  
      elemento.innerHTML=i;  
   i++;  
  }  
 }  

Método 3

Hemos de convertir el objeto HTMLCollection que contiene los tres HTMLLIElement en un array para poder luego recorrer los elementos del array con un bucle forEach.

 //Método 3  
 function myFunction() {  
  var list = document.getElementsByTagName("LI");  
  console.log(list);  
  //convertimos un object HTMLLIElement en un array  
  list_arr=Array.from(list);  
  list_arr.forEach((value, key) => {  
   value.innerHTML=key+1;  
  });  
 }  

jueves, 1 de agosto de 2019

Lanzar el script desde jQuery (1/2)

Esta entrada forma parte de una serie.
Habitualmente lo que interesa es ejecutar el código JavaScript después de que los elementos del DOM ya estén escritos en la página para luego poder interactuar con esas etiquetas, ids y clases desde el código JavaScript. Veamos posibles soluciones para conseguir esto.
  1. Poner el script justo antes de que se cierre el body. Antes del fin de etiqueta </body>. Esto no es muy aconsejable ya que lo indicado es que la llamada a los script se sitúen en el head.
  2. Usar document.onload tal y como se cuenta en la entrada: Comenzar la ejecución de un programa en Javascript al ir a una página
  3. Usar una función jQuery que llama al código JavaScript. Esta es la opción que vamos a tratar en este post.
Puede ver el código corriendo en:

HTML

Disponemos de una lista de frutas con tres clases.
  • <li class="rojas">
  • <li class="citricos">
  • <li class="cucurbitaceas">
  • <li class="dulces">
Llamamos en el head al código JavaScript usando un sistema propio de jQuery. Observe las dos líneas en el head. Primero llamamos al script js que contiene la versión 3.4.1 de jQuery. Seguidamente llamamos a nuestro script denominado dom5.js.


 <!DOCTYPE html>  
 <html>  
  <head>  
   <meta charset="utf-8">  
   <title>lanzar el JS desde el head</title>  
   <script src="https://code.jquery.com/jquery-3.4.1.min.js"></script>  
   <script type="text/javascript" src="dom5.js"></script>  
  </head>  
  <body>  
   <h1>Frutas</h1>  
   <ul>  
    <li class="rojas">Cereza</li>  
    <li class="citricos">Mandarina</li>  
    <li class="rojas">Frambuesa</li>  
    <li class="cucurbitaceas">Sandia</li>  
    <li class="dulces">Uvas</li>  
    <li class="rojas">Fresa</li>  
    <li class="citricos">Naranja</li>  
    <li class="dulces">Higos</li>  
    <li class="citricos">Pomelo</li>  
    <li class="rojas">Moras</li>  
    <li class="dulces">Piña</li>  
    <li class="cucurbitaceas">Melón</li>  
   </ul>  
   </section>  
  </body>  
 </html>  

JavaScript


Usando jQuery lo que hacemos es envolver todo el código JavaScript dentro de una función del tipo:

 $(function() {   
   //código js  
 });  

En el código JS lo que hacemos es establecer el color del fondo según cada uno de los cuatro tipos de clases que hemos definido. Esto nos permite establecer cuatro formas diferentes de trabajar con clases, para ilustrar diferentes formas de trabajar con el DOM.

  1. trabajando con getElementsByClassName y for(..of..)
  2. trabajando con getElementsByClassName y for clásico
  3. trabajando con querySelectorAll y forEach con función anónima
  4. trabajando con querySelectorAll y forEach con función de flecha
Podemos consultar una página que nos habla de querySelectorAll:
 $(function() {  
   'use strict'  
    
   //trabajando con getElementsByClassName y FOR(OF)  
   var claseRojas = document.getElementsByClassName("rojas");  
   for(var roja of claseRojas){  
    roja.style.background="pink";  
   };  
    
   //trabajando con getElementsByClassName y FOR clásico  
   var claseDulces=document.getElementsByClassName('dulces');  
   for(var i=0;i<claseDulces.length;i++){  
     claseDulces[i].style.backgroundColor="#00FF00";//verde   
   };  
    
   //trabajando con querySelectorAll y una clase (ver el .)  
   var claseCitricos=document.querySelectorAll(".citricos");  
   claseCitricos.forEach(function(item,index){  
    item.style.background="cyan";  
    console.log(index+": "+item.textContent);  
   });  
    
   //trabajando con querySelectorAll y forEach con función de flecha  
   var claseCucur=document.querySelectorAll(".cucurbitaceas");  
   claseCucur.forEach(item => item.style.background="yellow");  
   
  });  

¿Qué método prefieres de los cuatro para trabajar con clases?

miércoles, 31 de julio de 2019

JavaScript manejando el DOM con las clases

Este artículo forma parte de una serie que trata sobre el DOM (Document Object Model) y su manejo desde JavaScript.
  1. JavaScript manejo del DOM
  2. Manejar el DOM en JavaScript
  3. Cambiar color usando el DOM en JavaScript
  4. JavaScript manejando el DOM por sus etiquetas
  5. JavaScript manejando el DOM con las clases
  6. JavaScript manejando el DOM
En esta ocasión veremos como trabajar con las clases (class).


HTML

En el documento HTML tenemos una sección con id="seccionLunas" y unos cuantos li para crear una lista identificados por su clase (class).

 <!DOCTYPE html>  
 <html>  
  <head>  
   <meta charset="utf-8">  
   <title>modifica el DOM</title>  
  </head>  
  <body>  
   <section id="seccionLunas">  
    <h1>Satélites naturales</h1>  
   <ul>  
    <li class="marte">Phobos es la luna interior y la que más rápido gira.</li>  
    <li class="marte">Deimos es la luna exterior y la de giro más lento.</li>  
    <li class="marte">Phobos tiene una masa casi 5 veces mayor que Deimos.</li>  
    <li class="tierra">La Luna es el único satélite de la Tierra.</li>  
    <li class="jupiter">Ganímedes es la mayor luna de Júpiter.</li>  
    <li class="jupiter">Io es una luna de Júpiter.</li>  
    <li class="jupiter">Europa es unaluna de Júpiter.</li>  
    <li class="jupiter">Calisto es la mayor luna de Júpiter.</li>  
    <li class="saturno">Titán es la mayor luna de Saturno.</li>  
   </ul>  
   </section>  
   <!--scripts-->  
   <script src="dom4.js"></script>  
  </body>  
 </html>  

JavaScript

 'use strict'  
 //TRABAJAR EN EL DOM CON ELEMENTOS POR SU CLASE  
 console.log(("▼ 1 ").repeat(20));  
 var liMarte=document.getElementsByClassName('marte');  
 console.log(liMarte);  
 for(var i in liMarte){  
   if(liMarte[i].className=="marte"){  
     liMarte[i].style.backgroundColor="beige";  
   }  
 }  
 console.log("");  
   
 console.log(("▼ 2 ").repeat(20));  
 var liTierra=document.getElementsByClassName('tierra');  
 console.log(liTierra);  
 //si hacemos el siguiente for no es necesario un if  
 for(var i=0;i<liTierra.length;i++){  
   liTierra[i].style.fontStyle="italic";  
   liTierra[i].style.fontWeight="bold";  
   liTierra[i].style.backgroundColor="#00FF00";//verde  
 }  
 console.log("");  
   
 console.log(("▼ 3 ").repeat(20));  
   
 //con QUERYSELECTOR  
 var id=document.querySelector("#seccionLunas"); //con # actuamos sobre los id  
 console.log(id);  
 console.log("");  
   
 console.log(("▼ 4 ").repeat(20));  
 var claseMarte=document.querySelector(".marte");//con . actuamos sobre las clases  
 console.log(claseMarte); //muestra solo el primer elemento  
 console.log("");  
   
 console.log(("▼ 5 ").repeat(20));  
 var a=document.querySelectorAll(".marte"); //con querySelectorAll pillamos todos  
 console.log(a);  
 console.log("");  
   
 function toArray(domElements){  
  return Array.from(domElements);  
 }  
   
 console.log(("▼ 6 ").repeat(20));  
 console.log("usando HTMLCOLLECTION - FOREACH");  
 //seleccionamos con getElementById, getElementsByClassName, ...  
 var htmlcollection = document.getElementsByTagName('li');   
   
 /*  
 //esto no funciona, da erro, dice  
 //TypeError: htmlcollection.forEach is not a function  
 console.log(htmlcollection);//vemos que es una htmlcollection  
 htmlcollection.forEach((value, key) => {  
  console.log(key + " => " + value);  
 });  
 */  
 console.log("");  
   
 console.log(("▼ 7 ").repeat(20));  
 var htmlcollection_array = toArray(htmlcollection); // Convertimos en array convencional  
 htmlcollection_array.forEach((value, key) => { // Ya funciona  
  console.log(key + " => " + value.textContent);  
 });  
 console.log("");  
   
 console.log(("▼ 8 ").repeat(20));  
   
 console.log("Usando NODELIST - FOREACH");  
 //usamos una función de selección de tipo querySelector, querySelectorAll.  
 var nodelist = document.querySelectorAll("li");  
 console.log("");  
   
 console.log(("▼ 9 ").repeat(20));  
 console.log(nodelist); //comprobamos que es una nodelist  
 console.log("");  
   
 console.log(("▼ 10 ").repeat(16));  
 nodelist.forEach((value, key) => {  
  console.log(key + " => " + value.textContent);  
 });  
 console.log("");  
   
 console.log(("▼ 11 ").repeat(16));  
 console.log("usando AMBOS - FOR(..IN...)");  
   
 //para evitar usar if dentro del bucle tanto para htmlcollection como para nodelist  
 //deben ser pasados a arrays  
 //para htmlcollection ya tenemos htmlcollection_array  
   
 var nodelist_array = toArray(nodelist);  
 for(let key in nodelist_array){ //funciona bien sin if  
  console.log(key, nodelist_array[key].textContent);  
 }  
 console.log("");  
   
 console.log(("▼ 12 ").repeat(16));  
   
 for(let key in htmlcollection_array){ //funciona bien sin if  
  console.log(key, htmlcollection_array[key].textContent);  
 }  
 console.log("");  
   
 console.log(("▼ 13 ").repeat(16));  
   
 console.log("usando FOR(..OF...) ponemos fondo azul");  
 //Otra forma que no necesita if es FOR(...OF...)  
 var jovianos = document.getElementsByClassName("jupiter"); //satélites jovianos  
 for(let joviano of jovianos){  
  joviano.style.background = "cyan";  
 }  
 console.log("");  
   
 console.log(("▼ 14 ").repeat(16));  
   
 //usando FOR(...IN...) pero es necesario un IF  
 //si necesitamos poner el if con un FOR(...IN...)  
 var rediv=document.getElementsByClassName("marte");  
 for(var value in rediv){  
  if(typeof rediv[value]=="HTMLLIElement"){  
   rediv[value].style.color="blue";//tinta azul  
  }  
  console.log("este es de marte: "+rediv[value]);  
 }  
 //si no hubieramos puesto el if si funcionaría la tinta azul pero  
 //la consola daría un error porque intenta poner azul elementos  
 //que no son texto y que van en la colección.  

Las colecciones del tipo HTMLcollection no aceptan bucles forEach para ser recorridas y así poder sacar sus elementos. Lanzan un error diciendo:

TypeError: htmlcollection.forEach is not a function

Un posible solución es emplear un bucle for del tipo for(...in...) pero en este caso al pedir con style que los elementos del HTMLcollection tomen determinado atributo, como por ejemplo, un color, se hace necesario añadir un condicional if para evitar que el código intente añadir un color a los elementos finales de la colección que ya no son puro texto.

En el código se presentan otras formas de establecer bucles para que no sea necesario usar ese condicional if y que sin embargo podamos añadir ciertos estilos (style) como por ejemplo el color, únicamente a los elementos que son de puro texto.
  • Un sistema consiste en convertir la colección en un array con toArray() y así luego ya podamos aplicar un forEach
  • Un sistema que funciona estupendamente es hacer un for(...of...)

Para iterar elementos del DOM es más interesante usar for(...of...). A diferencia del "for in" la variable "div" no toma los índices, toma los valores de cada índice que es lo que habitualmente queremos. Con "for in" obtienes indices y con "for of" obtienes valores.

Si usamos funciones del tipo querySelectorAll, que son similares a JQuery, si podremos usar un forEach sin problemas ya que lo que devuelven es un objeto del tipo NodeList.



JavaScript manejando el DOM por sus etiquetas

Este artículo forma parte de una serie que trata sobre el DOM (Document Object Model) y su manejo desde JavaScript.
  1. JavaScript manejo del DOM
  2. Manejar el DOM en JavaScript
  3. Cambiar color usando el DOM en JavaScript
  4. JavaScript manejando el DOM por sus etiquetas
  5. JavaScript manejando el DOM con las clases
  6. JavaScript manejando el DOM
En un artículo anterior ya hemos hablado de cómo manejar el DOM desde JavaScript utilizando el id de las etiquetas <div> entre otras, ahora continuamos profundizando en el manejo del DOM utilizando sus etiquetas: <h1>, <p>, <div>, <span>, <section>, ...

En muchos casos el HTML de las página web utiliza etiquetas que no llevan ningún id y simplemente tenemos que manejarlas haciendo referencia al tipo de etiqueta de que se trata y cuando son varias del mismo tipo, por ejemplo varios <div> podemos recogerlos todos y luego tratarlos por el número que ocupan dentro del HTMLCollection que hemos capturado. Este contenedor actua como un array donde los elementos son todos los <div> capturados.

Página en Firefox y consola con F12.

HTML

Tenemos un div inicial con etiqueta id="micaja". Con este hemos trabajado en el post citado. Ahora creamos tres div sin etiqueta. Cuando trabajemos con ellos nos referiremos a cada uno de ellos de forma individual por el índice que ocupan en una array que se puede formar con ellos.
También hemos añadido una sección con etiqueta id="miseccion".

 <!DOCTYPE html>  
 <html>  
  <head>  
   <meta charset="utf-8">  
   <title>modifica el DOM</title>  
  </head>  
  <body>  
   <h1>Manejamos de DOM</h1>  
   <p>Estamos manejando el DOM desde código JS.</p>  
   <div id="micaja">Texto inicial del cuerpo</div>  
   <div>Este es el div 1.</div>  
   <div>Este es el div 2.</div>  
   <div>Este es el div 3.</div>  
   <section id="miseccion">  
    <hr>  
    <h1>Listado de los textos de los DIVs</h1>  
   </section>  
   <!--scripts-->  
   <script src="dom3.js"></script>  
  </body>  
 </html>  

JavaScript

Tenemos dos zonas de código.

  • (línea 3)   Trabajar con elementos con un id concreto  (esto ya se vió en el post citado al inicio)
  • (línea 18) Trabajar con elementos por su etiqueta  (ésta es la parte nueva)
https://repl.it/@valoro/JS-DOM3

 'use strict'
//Seleccionar y modificar elementos del DOM

// TRABAJAR CON ELEMENTOS CON UN ID CONCRETO

//Veo el contenido del ID completo (como objeto)
var caja = document.getElementById("micaja");
//console.log(caja);

//Veo el texto del ID
caja = document.getElementById("micaja").innerHTML;
//console.log(caja);

//Puedo modificar el texto desde JS
caja = document.getElementById("micaja");

caja.innerHTML = "Nuevo texto escrito desde JS";
//console.log(caja.innerHTML);

//Cambio el style de la caja
caja.style.color = "red";
caja.style.backgroundColor = "yellow";
caja.style.border = "thick solid #0000FF";


//TRABAJAR CON ELEMENTOS POR SU ETIQUETA
//declaramos una variable que es un HTMLcollection (similar a un array)
// que captura todas las etiquetas
var todosLosDiv = document.getElementsByTagName("div");

console.log(todosLosDiv); //se muestra el HTMLcollection con todos los div

var contenidoEnTexto2 = todosLosDiv[2]; //podemos elegir un elemento concreto del HTMLcollection

console.log(contenidoEnTexto2.textContent);  //textContent captura el texto contenido

//textContent es similar a innerHTML aunque este último permite asignar contenido
contenidoEnTexto2.innerHTML = "Otro texto para el DIV 2";
console.log(contenidoEnTexto2);//muestra todo el div no solo el textContent
contenidoEnTexto2.style.backgroundColor = "cyan"; //puedo manejar los estilos

for (let valor in todosLosDiv) {
    //con el if evitamos tres undefined que se mustran al final y no son div
    if (typeof todosLosDiv[valor].textContent == "string") {
        var parrafo = document.createElement("p"); //creamos un elemento de parrafo
        //pillamos en la variable texto todos los textos de los div
        var texto = document.createTextNode(todosLosDiv[valor].textContent);
        parrafo.append(texto); //anexamos el texto al elemento parrafo creado
        //parrafo.appendChild(texto); //también funcionaría con appendChild
        //anexamos el párrafo a la sección "miseccion"
        document.querySelector("#miseccion").append(parrafo);
        //si en lugar de append ponemos prepend inserta el parrafo invirtiendo el orden de los div
    }
}
var hr = document.createElement("hr");//creamos un hr
miseccion.append(hr);//el hr lo añadimos al final
hr.style.borderColor = "red";//el hr será rojo. Esta línea no funciona en algunos navegadores

lunes, 29 de julio de 2019

Cambiar color usando el DOM en JavaScript

Este artículo forma parte de una serie que trata sobre el DOM (Document Object Model) y su manejo desde JavaScript.
  1. JavaScript manejo del DOM
  2. Manejar el DOM en JavaScript
  3. Cambiar color usando el DOM en JavaScript
  4. JavaScript manejando el DOM por sus etiquetas
  5. JavaScript manejando el DOM con las clases
  6. JavaScript manejando el DOM
En esta ocasión vamos a diseñar un caso práctico donde podemos cambiar el color del texto y del fondo de forma aleatoria pulsando un botón.


HTML

El documento se llama index.html.

Creamos un div con el id="zona". Creamos un botón que al ser pulsado lanza una función de JavaScript.

 <!DOCTYPE html>  
 <html>  
  <head>  
   <meta charset="utf-8">  
   <title>manejo del DOM</title>  
   <link href="dom2.css" rel="stylesheet" type="text/css" />  
  </head>  
  <body>  
   <div id="zona">¡Hola!</div>  
   <div>  
    <br>  
    <button type="button" onclick="mifuncion()">Cambia el color aleatoriamente</button>  
   </div>  
   <script src="dom2.js"></script>  
  </body>  
 </html>  

CSS

El documento se llama dom2.css. Proporcionamos unos valores iniciales para los colores de texto y fondo. Definimos el tamaño de nuestro rectángulo.

 #zona {  
    width: 200px;  
    height: 60px;  
    background-color: beige;  
    color: grey;  
    text-align: center;  
    font-size: 250%;  
    }  
    button{  
        height:50px;  
        width:150px;  
       }  

JavaScript

El documanto se llama dom2.js

Si tuviéramos un valor concreto de color rgb hubieramos escrito, por ejemplo:

rectangulo.style.color='rgb(50,200,100)';

Al usar variables aleatorias hemos tenido que concatenarlas para formar nuestro código.


 var rectangulo=document.getElementById("zona");  
 function mifuncion() {  
  var a=Math.floor(Math.random()*255);  
  var b=Math.floor(Math.random()*255);  
  var c=Math.floor(Math.random()*255);  
  var x=Math.floor(Math.random()*255);  
  var y=Math.floor(Math.random()*255);  
  var z=Math.floor(Math.random()*255);  
  rectangulo.style.backgroundColor='rgb('+a+','+b+','+c+')';  
  rectangulo.style.color='rgb('+x+','+y+','+z+')';  
 }  

domingo, 28 de julio de 2019

JavaScript manejo del DOM

Este artículo forma parte de una serie que trata sobre el DOM (Document Object Model) y su manejo desde JavaScript.
  1. JavaScript manejo del DOM
  2. Manejar el DOM en JavaScript
  3. Cambiar color usando el DOM en JavaScript
  4. JavaScript manejando el DOM por sus etiquetas
  5. JavaScript manejando el DOM con las clases
  6. JavaScript manejando el DOM
El DOM contiene, en forma de arbol, todos los elementos que podemos manejar de una página web entendida como documento. Podemos manejar todas aquellas etiquetas que utilizamos: <p> párrafos, <div> cajas, <h1> etiquetas de texto, <span> contenedor en línea, ...



Veamos un ejemplo inicial donde vamos a trabajar leyendo, modificando y alterando propiedades de un elemento <div> identificado por su id.

En el documento HTML es importante poner la llamada al script al final del body par que de tiempo a que se escriba la página web tal y como se ha definido en el documento html y que luego el código JS pueda leer y alterar lo escrito. Si ponemos los script arriba en el body o incluso en el head podremos comprobar que nuestro código no es capaz de leer o modificar lo escrito, ya que aún no se ha escrito por parte del código HTML.


https://repl.it/@valoro/JS-DOM1

HTML

Observe que llamamos al código JavaScript con una línea antes de que finalice el body. Lo aconsejable es llamar al script dentro del head. De este tema se habla en la siguiente entrada del blog:

 <!DOCTYPE html>  
 <html>  
  <head>  
   <meta charset="utf-8">  
   <title>modifica el DOM</title>  
  </head>  
  <body>  
   <div id="micaja">Texto inicial del cuerpo</div>  
   <!--Scripts -->  
   <script src="dom1.js"></script>  
  </body>  
 </html>  

JavaScript

 'use strict'  
 //DOM = Document Object Model  
   
 //Veo el contenido del ID completo (como objeto)  
 var caja=document.getElementById("micaja");  
 console.log(caja);  
   
 //Veo el texto del ID  
 caja=document.getElementById("micaja").innerHTML;  
 console.log(caja);  
   
 //Puedo modificar el texto desde JS  
 caja=document.getElementById("micaja");  
 caja.innerHTML="Nuevo texto escrito desde JS";  
 console.log(caja.innerHTML);  
   
 //Cambio el style de la caja  
 caja.style.color="red";  
 caja.style.backgroundColor="yellow";  
 caja.style.padding="20px";  
   
 //Usando la función cambiaColor  
 cambiaColor("beige");  
   
 function cambiaColor(color){  
   caja.style.background=color;  
  }  

En la línea 5 del código anterior podemos leer:

var caja=document.getElementById("micaja");

Esta expresión puede ser sustituida por la siguiente obteniendo el mismo resultado.

var caja=document.querySelector("#micaja");

Con este segundo método estamos usando un querySelector y estamos haciendo referencia a "#micaja" de forma similar a como lo haríamos en CSS con el uso de # y el id.

Seguidamente se muestran los textos que se ven en pantalla a medida que el código va actuando.







domingo, 21 de julio de 2019

Manejar el DOM en JavaScript

Este artículo forma parte de una serie que trata sobre el DOM (Document Object Model) y su manejo desde JavaScript.
  1. JavaScript manejo del DOM
  2. Manejar el DOM en JavaScript
  3. Cambiar color usando el DOM en JavaScript
  4. JavaScript manejando el DOM por sus etiquetas
  5. JavaScript manejando el DOM con las clases
  6. JavaScript manejando el DOM
El DOM nos permite acceder y editar el contenido y características de la página web. Veamos un caso práctico en el que se nos piden tres cosas.
  1. Parte 1 Obtener la lista de elementos de etiqueta <p> y mostrarlos en un alert de JavaScript.
  2. Parte 2. Añadir un nuevo elemento <p> con el texto “Texto del nuevo párrafo” y que sea hijo del body.
  3. Parte 3. Igual que la parte 2 pero añadido en una posición aleatoria en luegar de añadirse siempre abajo.

La solución propuesta es la siguiente.

HTML

Creamos cuatro párrafos A, B, C y D.
Cremos tres botones.
  1. Primer botón para la parte 1 del caso práctico. Recopila los párrafos y los mustra en un alert.
  2. Segundo botón para la parte 2 del caso práctico. Crea e inserta un nuevo párrafo.
  3. Tercer botón para la parte 3. El texto nuevo se inserta en una posición aleatoria.


 <!DOCTYPE html>   
  <html>   
  <head>   
   <meta charset="utf-8">   
   <title>Páginas interactivas con JavaScript</title>   
   <link href="style.css" rel="stylesheet" type="text/css" />  
  </head>   
  <body>   
   <h1>Manejar el DOM</h1>   
   <h2>Document Object Model</h2>   
   <div id="contenido">   
   <p>Párrafo A</p>   
   <p>Párrafo B</p>   
   <p>Párrafo C</p>   
   <p>Párrafo D</p>   
   </div>   
   <button onclick="miFuncion1()">Recopila párrafos</button>  
   <br><br>   
   Crear nuevo párrafo &rarr; <button onclick="miFuncion2()">Nuevo párrafo</button>  
   <br><br>   
   Crear nuevo párrafo<br>  
   en posición aleatoria&rarr; <button onclick="miFuncion3()">Parrafo desordenado</button>  
   <script type="text/javascript" src="script.js"></script>   
  </body>   
  </html>  

CSS

Damos un poco de estilo a la página.

 h1 {   
    text-align: center;   
    text-transform: uppercase;   
    color: #4CAF50;   
   }   
   h2 {   
    text-align: center;   
    color: blue;   
   }   
   p {   
    text-indent: 50px;   
    text-align: justify;   
    letter-spacing: 3px;   
   }   

JavaScript

Parte 1

La parte 1 del ejercicio nos pide mostrar un alert con todos los párrafos existentes.



Creamos la variable parrafos con

document.getElementsByTagName("p")

Esto crea un objeto HTMLCollection con cuatro elementos del tipo HTMLParagraphElement que comienzan a numerarse por cero.


Luego con un bucle for recorremos los cuatro elementos para ir añadiendo su contenido en la variable acumulativa texto.
En este caso ha sido necesario utilizar el método item que permite acceder a cada uno de los elementos del HTMLcollection indicándo su índice.

Utilizamos innerHTML pero en este caso también podríamos haber utilizado innrText ya que únicamente estamos tomando el texto de las etiquetas de párrafo y no estamos tomando o modificando su contenenido HTML.

 // PARTE 1   
 function miFuncion1(){   
  var texto="";   
  var parrafos = document.getElementsByTagName("p");   
  for(var i=0;i<parrafos.length;i++){   
  texto+=parrafos.item(i).innerHTML+", ";   
  };   
  texto=texto.slice(0, -2)+".";//cambia la última coma por punto   
  alert(texto);   
 }  

Parte 2

La parte 2 del ejercicio nos pide insertar un nuevo párrafo. Lo más sencillo es insertarlo abajo, después de todos los demás elementos.

 // PARTE 2  
 function miFuncion2(){  
         var nuevotexto = document.createElement("p");  
         nuevotexto.innerHTML = "Texto del nuevo párrafo";  
         document.body.appendChild(nuevotexto);  
     }  

Parte 3

La parte 3 del ejercicio nos pide insertar un nuevo párrafo. Hemos añadido la característica de que los nuevos párrafos estén numerados y que se añadan en una posición aleatoria dentro de los párrafos ya existentes.


 // PARTE 3   
 var i=0; //i se usa para numerar los nuevos párrafos   
 function miFuncion2(){   
  i+=1;   
  var parrafos = document.getElementsByTagName("p"); //cuenta los que hay   
  var nuevo_parrafo = document.createElement('p'); //crea una nueva etiqueta p   
  var texto = document.createTextNode('Texto del nuevo párrafo '+i);   
  nuevo_parrafo.appendChild(texto); //añade el texto a la nueva etiqueta p   
  var alea=Math.floor(Math.random() * parrafos.length); //posición aleatoria   
  //definimos la variable parrafo_ref que es el párrafo de referencia   
  //el párrafo de referencia se usa para saber después de quien va el nuevo párrafo   
  //dentro de los corchetes [] se pone la posición donde ira el nuevo   
  var parrafo_ref = document.getElementById('contenido').getElementsByTagName('p')[alea];   
  //insertarmos el nuevo parrafo antes del parrafo de referencia   
  document.getElementById('contenido').insertBefore(nuevo_parrafo,parrafo_ref);   
  //si ponemos [-1] en el nuevo párrafo se insertará al final   
  //si ponemos [0] en el nuevo párrafo se insertará al principio   
 }