Scraping

Web scraping es una técnica utilizada mediante programas de software para extraer información de sitios web. Usualmente, estos programas simulan la navegación de un humano en la World Wide Web ya sea utilizando el protocolo HTTP manualmente, o incrustando un navegador en una aplicación.
Wikipedia: Web Scraping

Me jodio un buen rato el ; del final del require, creo que es importante que para node siempre se use. Pensé que el profesor lo hacía por costumbre… pero no

Para los que estén en WSL2, y les salga un error de este estilo:

error  while loading shared libraries: libatk-1.0.so.0: cannot open shared object file: No such file or directory

*Lo de “libatk” puede decir cualquier cosa con lib, prueben el siguiente comando

sudo apt-get install -y libgbm-dev

Si y SOLO SI no les funciona, prueben este comando también

sudo apt-get install -yq --no-install-recommends libasound2 libatk1.0-0 libc6 libcairo2 libcups2 libdbus-1-3 libexpat1 libfontconfig1 libgcc1 libgconf-2-4 libgdk-pixbuf2.0-0 libglib2.0-0 libgtk-3-0 libnspr4 libpango-1.0-0 libpangocairo-1.0-0 libstdc++6 libx11-6 libx11-xcb1 libxcb1 libxcursor1 libxdamage1 libxext6 libxfixes3 libxi6 libxrandr2 libxrender1 libxss1 libxtst6 libnss3

En cualquiera de los dos casos les dará un error

Unable to open X display.

Al estar en un subsistema, no podemos ver pantallas, por lo que puppeteer en WSL solo funciona removiendole headless.

Cambiamos esta linea

const browser = await puppeteer.launch({ headless: false });

A esto:

const browser = await puppeteer.launch();

⚠️No vamos a poder ver la pagina en el navegador como en la clase, pero recuerden, puppeteer se usa mas que nada para ver una página sin necesidad de cargarla visualmente. Hay más métodos para usar puppeteer en windows, pero este es la manera mas sencilla que he encontrado para que funcione

Hice un ‘scraper’ que me trae los comentarios de cualquier blogpost de Platzi, espero les guste ❤️

const puppeteer = require('puppeteer');
const link = 'https://platzi.com/blog/que-es-platzi-master/';

(async function browser() {
    console.log('Abrimos chromium')
    const browser = await puppeteer.launch({headless: false})//lanzamos el navegador

    const page = await browser.newPage()
    await page.goto(link)

    const commentsText = await page.evaluate(() => {
        const comments = document.querySelectorAll('.CommentContent-text p')
        const listOfComments = []
        comments.forEach(comment => {
            listOfComments.push(comment.innerHTML)
        })
        return listOfComments
    })

    browser.close()

    
    console.log(commentsText)
})()

Esto es solo como para saber que existe. Pero para profundizar es necesario ver curso de scrapig o cacharrear.

const puppeteer = require('puppeteer');

(async () => {
    console.log('lanzamos navegador');
    // const browser = await puppeteer.launch();
    const browser = await puppeteer.launch( { headless: false } );

    const page = await browser.newPage();
    await page.goto('https://es.wikipedia.org/wiki/Node.js');

    var titulo1 = await page.evaluate(()  => {
        const h1 = document.querySelector('h1');
        console.log(h1.innerHTML);
        return h1.innerHTML;
    });

    console.log(titulo1);
    console.log('Cerramos navegador');
    browser.close();
    console.log('Navegardor cerrado');
}) ();

Para los que están en windows corriendo con WSL, he buscando pero al parecer no es posible hacerlo, les recomiendo que creebn otra carpeta limpia y lo hagan con la consola powersell de windows funciona bien.

En la página de github de puppeteer se puede encontrar más documentación sobre las cosas que este paquete hace. Aca comparto el enlace: https://github.com/puppeteer/puppeteer

Con Puppeteer no solo podemos leer la informacion de la pagina, tambien podemos lazar eventos de click para editar o ejecutar acciones en dicha pagina, una ves lo utilice para cargar una pagina, buscar un boton y clickearlo, para despues agarrar un texto que aparecia en pantalla la cual era una token y utilizar esta en mis request.
Aparte con Puppeteer podemos crear PDFs a patir de HTML, entre otras cosas!

Puppeteer es hecho por google, recuerdo haber visto el directo cuando lo presentron, dele un ojo a su npm, es muy util el poder saber todas las posibilidades de ese, asi tienen mas maneras de solucionar sus problemas!

Un resumen de la clase

/*
  Entendiendo web scrapping con puppeteer...
  Funciona de forma asincrona
*/
const puppeteer = require('puppeteer');

// Funcion autoejecutable
(async () => {
  console.log('Lanzar el navegador');
  // const browser = await puppeteer.launch();
  /*
    {headless: false} lo que hace es que el navegador no
    se lance en segundo plano
  */
  const browser = await puppeteer.launch({headless: false});
  // Abrir una pagina en el navegador
  const page = await browser.newPage();
  // Ir a una pagina
  await page.goto('https://wikipedia.org/wiki/Node.js');
  /*
    Ejecutar un script, con page.evaluate,
    lo que hace es evaluar lo que le digamos dentro de la pagina y
    devolver el resultado
  */
  const titulo1 = await page.evaluate(() => {
    const h1 = document.querySelector('h1');
    return h1.innerHTML;
  });
  console.log(titulo1);
  // Usamos browser.close para cerrar el navegador despues de haber extraido los datos;
  console.log('Cerrando el navegador');
  browser.close();
  console.log('Navegador cerrado');

})();```

npm init –y 

npm i puppeteer

Qué divertido y que ganas de programar bots que me dió esto jaja.

Las función que describe el profesor se llaman IIFE: Funciones que se ejecutan tan pronto como se definen: https://developer.mozilla.org/es/docs/Glossary/IIFE

Me daba error no abria Chrome, lo pude solucionar así:

const puppeteer = require("puppeteer");
const PATHS = {
	win32: {
		executablePath:
			"C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
		userDataDir: "C:\\Users\\TuNombreDeUsuario\\AppData\\Local\\Temp\\puppeteer_user_data",
	},
	linux: {
		executablePath:
			"/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
		userDataDir: "/mnt/c/Users/TuNombreDeUsuario/AppData/Local/Temp/puppeteer_user_data",
	},
};

(async () => {
	console.log("Lanzamos navegador!");

	const browser = await puppeteer.launch({
		headless: false,
		executablePath: PATHS[process.platform].executablePath,
		userDataDir: PATHS.win32.userDataDir,
		defaultViewport: null,
	});

	const page = await browser.newPage();
	await page.goto("https://es.wikipedia.org/wiki/Node.js");

	console.log("Cerramos Navegador...");
	// browser.close();
	console.log("Navegador cerrado");
})();

Sí tienen problemas instalando puppeteer:

• reintenten el comando

npm init –y 

• y después reintenten la instalación

npm i puppeteer

Para los que utilizan wsl2 esta es la mejor solucion que pude encontrar

const browser = await puppeteer.launch({
        args: [
            '--disable-gpu',
            '--disable-dev-shm-usage',
            '--disable-setuid-sandbox',
            '--no-first-run',
            '--no-sandbox',
            '--no-zygote',
            '--single-process',
        ]
    });```

Muy Muy poderoso, para los que tienen problemas con puppeteer en wsl2 lo solucione de la siguiente manera:

Instalar chrome en wsl2 siguiendo este tutorial:
Link

en el codigo agregar está linea

    const browser = await puppeteer.launch({
        args: [
            '--disable-gpu',
            '--disable-dev-shm-usage',
            '--disable-setuid-sandbox',
            '--no-first-run',
            '--no-sandbox',
            '--no-zygote',
            '--single-process',
        ]
    }); // default is true

Curso de web Scraping

Yo tuve un problema al lanzar el navegador por que uso la consola WSL en VS code, lo logre con cmd, solo tuve que reinstalar puppeteer para que cargara de nuevo chromium y desde CMD ejecutar el código

Función auto-ejecutable: ( async () => { } ) ()

const puppeteer =  require('puppeteer')


const run = async ()=>
{
    const browser = await puppeteer.launch()
    const page = await browser.newPage()


    // TOMAR UN SCREENSHOT
    // await page.goto('https://platzi.com/cursos/html5-css3/opiniones/1/');
    
    // await page.screenshot({
        //     path: 'screenshot.png',
        //     fullPage: true
        // })
    
    async function getPageData() {
        
        await page.goto('https://platzi.com/cursos/html5-css3/opiniones/1/');

        const data = await page.evaluate(()=>{
            
            const $reviews = document.querySelectorAll('.Review')
            const data = []

            $reviews.forEach(($reviews)=>{

                let description = $reviews
                                  .querySelector('.Review-description')
                                  .textContent
                                  .trim()

                let name = $reviews
                           .querySelector('.Review-info .Review-name strong')
                           .textContent
                           .trim()
              
                let starts = $reviews
                             .querySelector('.Review-info .Review-stars')
                             .querySelectorAll('.fulled')
                             .length
                

                data.push({
                    content: description,
                    name:  name,
                    starts : starts
                })
            })
            return {
                reviews: data,
            }
        })
    
        console.log("DATA,", data);
        
    }

    getPageData()

    // await browser.close()
    
}

run()

Al parecer Scraping no es tan scrap xd… está genial esta información 😄

Qué poder!
.
Ya sé que otro curso quiero tomar 🤩

Está genial! Lo probé creand un servidor en node y mostrando ahí el listado de cursos que tengo en Platzi, con su badge y enlace al diploma, como idea para la web personal 🙈

//En los require es importante poner un ';' para decirle a JS donde termina nuestra línea.
const puppeteer = require('puppeteer');


//Sintaxis de función autoejecutable: ponemos toda la función en un paréntesis, luego al final de ella, ponemos al lado que la ejecutamos ()
(async () => {

    //Iniciar, lanzar o abrir el navegador. Es importante cerrarla al final para que no se quede abierto, esta función es asíncrona:
    console.log('Iniciando navegador!')
    const browser = await puppeteer.launch();
    //Si queremos ver como el navegador se abre y que no sea solo el servidor que lo haga, launch recibe un parámetro el cual es un objeto, en ello si queremos visualizar el proceso debemos colocar a ese objeto un atributo 'headless' como false

    //Iniciamos una página en el navegador, es asíncrona:
    const page = await browser.newPage()

    //Le decimos a la página con el método de newPage llamado goto() que queremos irnos a la URL que pasaremos como argumento. Es asíncrono
    await page.goto('https://cayolegal1.github.io/Curriculum/')

    //Agarrando algún atributo con el método de page llamado evaluate, el cual recibe una función como argumento. Podemos hacer como si fuera que estamos en nuestro espacio de desarrollo local y agarrar lo que nos interese. Todo esto también es asíncrono

    const elements = await page.evaluate(() => {

        const title = document.querySelector('h1').textContent
        const img = document.querySelector('img').src
        const p = document.querySelector('p').textContent
        return [title, img, p]

    })

    //Podemos retornar por cada método un elemento o bien hacerlo todo de una como ahora, en un arreglo, cabe resaltar que es importante retornar el o los elementos ya que si no retornamos nada nos dará undefined

    elements.forEach(el => console.log(el))
    
    //Cerramos el navegador:
    console.log('Cerrando el navegador...')
    //browser.close();
    console.log('Navegador cerrado')

})();

Épicardo!

Hola, alguien sabe como solucionar este error, al parecer no puede ejecutar el navegador
mi equipo tiene windows 10

• wsl 2 ubuntu 20.04
• node 14.15.4
  Parece que es la falta de algunos paquetes
  
  

Para los que tengan problemas usando WSL2 y no les haya funcionado los comandos que compartió el compañero miren esto: me sirvió.
https://stackoverflow.com/questions/67407104/error-while-loading-shared-libraries-libgbm-so-1-cannot-open-shared-object-fil

Alguien puede ayudarme.

Al momento de intentar instalar puppeteer en windows, me muestra lo sienguiente:

npm i puppeteer
npm ERR! Unexpected end of JSON input while parsing near '...8KoI+BNOXEOKHnEoHOOdw'

npm ERR! A complete log of this run can be found in:
npm ERR!     C:\Users\PayOne-Desarrollo\AppData\Roaming\npm-cache\_logs\2020-08-08T05_15_44_395Z-debug.log

Por lo tanto veo el Log que crea, ya investigue pero aun no sè en donde estoy fallando.

0 info it worked if it ends with ok
1 verbose cli [
1 verbose cli   'C:\\Program Files\\nodejs\\node.exe',
1 verbose cli   'C:\\Users\\PayOne-Desarrollo\\AppData\\Roaming\\npm\\node_modules\\npm\\bin\\npm-cli.js',
1 verbose cli   'i',
1 verbose cli   'puppeteer'
1 verbose cli ]
2 info using npm@6.14.2
3 info using node@v12.16.1
4 verbose npm-session f986ea364ffc6fd4
5 silly install loadCurrentTree
6 silly install readLocalPackageData
7 http fetch GET 304 https://registry.npmjs.org/puppeteer 1323ms (from cache)
8 silly fetchPackageMetaData error for puppeteer@latest Unexpected end of JSON input while parsing near '...8KoI+BNOXEOKHnEoHOOdw'
9 timing stage:rollbackFailedOptional Completed in 0ms
10 timing stage:runTopLevelLifecycles Completed in 1380ms
11 verbose stack SyntaxError: Unexpected end of JSON input while parsing near '...8KoI+BNOXEOKHnEoHOOdw'
11 verbose stack     at JSON.parse (<anonymous>)
11 verbose stack     at parseJson (C:\Users\PayOne-Desarrollo\AppData\Roaming\npm\node_modules\npm\node_modules\json-parse-better-errors\index.js:7:17)
11 verbose stack     at C:\Users\PayOne-Desarrollo\AppData\Roaming\npm\node_modules\npm\node_modules\node-fetch-npm\src\body.js:96:50
11 verbose stack     at processTicksAndRejections (internal/process/task_queues.js:97:5)
12 verbose cwd C:\Users\PayOne-Desarrollo\Documents\PLATZI\CURSO DE FUNDAMENTOS DE NODEJS\herramientas\scrapping
13 verbose Windows_NT 10.0.18363
14 verbose argv "C:\\Program Files\\nodejs\\node.exe" "C:\\Users\\PayOne-Desarrollo\\AppData\\Roaming\\npm\\node_modules\\npm\\bin\\npm-cli.js" "i" "puppeteer"
15 verbose node v12.16.1
16 verbose npm  v6.14.2
17 error Unexpected end of JSON input while parsing near '...8KoI+BNOXEOKHnEoHOOdw'
18 verbose exit [ 1, true ]

Puppeteer es una herramienta dentro de Node.js para hacer scraping con Javascript.

Instalar
npm init -y
npm i puppeteer

(async ()=>{
    console.log("Start browser")
    /*const browser = await puppeteer.launch();*/ /*open*/
    const browser = await puppeteer.launch({headless: false});
    const page = await browser.newPage();
    await page.goto(`https://platzi.com`);
    var title = await page.evaluate(
        ()=>{
            const h1 = document.querySelector(`h1`);
            console.log(h1.innerHTML);
            return h1.innerHTML
        }
    );
    console.log(title);
    /* browser.close();
    console.log("Close browser"); */
})();

woow esto es genial, yo habia hecho esto a mano con funciones de js, pero tenía que correrlas en la consola de la página web para que se ejecutará el código.

const puppeteer = require('puppeteer');

( async() => {
    console.log('Lanzamos navegador!!');
    const browser =  await puppeteer.launch( {headless: false});

    const page = await browser.newPage();
    await page.goto('https://www.carlosramirezflores.com/');

    var titulo = await page.evaluate( () => {
        const h1 = document.querySelector('h1');
        console.log(h1.innerHTML);
        return h1.innerHTML;
    })
    console.log(titulo);
    console.log('cerramos navegador!!');
    browser.close();
    console.log('Navegador cerrado!!');
})();```
https://www.carlosramirezflores.com/

Una excelente clase, me encanto demasiado la herramienta, tomare el curso de Web Scraping, para aprender más sobre este tema.

Anexo mi ejemplo, espero y sea de utilidad.

<
const puppeteer = require('puppeteer');

(async() => {

    console.log('Lanzamos Navegador'); 
    const browser = await puppeteer.launch({headless: false}); //Lanzar chromium y visualizar operación

    const page = await browser.newPage(); //Ordenar a chromium abrir una nueva pagina
    await page.goto('https://es.wikipedia.org/wiki/JavaScript'); //URL de nueva pagina

    //
    var titulo1 = await page.evaluate(() => { //page.evaluate ejecuta un script dentro de la pag
        const h1 = document.querySelector('h1');  // seleccióna una propiedad dentro de la pag
        console.log(h1.innerHTML); // trae a consola el elemento h1(titulo) dentro del html de la pag
        return h1.innerHTML;
    })
    var parrafo1 = await page.evaluate(() => { //page.evaluate ejecuta un script dentro de la pag
        const p = document.querySelector('p');  // seleccióna una propiedad dentro de la pag
        console.log(p.innerHTML); // trae a consola el elemento p(parrafo) dentro del html de la pag
        return p.innerHTML;
    })
    
    console.log('Titulo del articulo: ', titulo1);

    console.log('Parrafo del articulo: ', parrafo1);

    //
    console.log('Cerramos navegador')
    browser.close();   //Cerrar chromium después de ejecutarse acciones 
    console.log('Navegador cerrado')

}) ();
>

Y así hice Scraping a mi puntaje en Platzi :

// Ejecutar Script en la página
    var titulo1 = await page.evaluate(() => {
        const Puntos = document.querySelector('.ProfileScore-number');
        console.log(Puntos.innerHTML);
        
        return Puntos.innerHTML;
    })

Le di toda la tarde y definitivamente no lo pude hacer en WSL, a alguien más le pasò? busque en varios foros y al parecer la intalación de puppeteer no es tan efectiva en wsl, alguna opinion?

También se puede hacer un fetch al HTML y crear un DOM a partir de él

Carlos en esta clase usa una estructura llamada IIFE, acá dejo algo de documentación

Uso mac y no tuve la misma salida en consola con “innerHTML”, usé “innerText”:

const pup = require('puppeteer');

(async ()=>{
    console.log('lanzamos navegador');
    //const browser = await pup.launch();
    const browser = await pup.launch({headless:false});
    const page = await browser.newPage();
    await page.goto('https://es.wikipedia.org/wiki/Node.js')
    // acciones
    var titulo1 = await page.evaluate(()=>{
        const h1 = document.querySelector('h1');
        console.log(h1.innerText);
        return h1.innerText;
    })
    //imprimimos
    console.log(titulo1);
    console.log('cerramos navegador');
    browser.close();
    console.log('navegador cerrado');
})();

Esto del web scrapping esta muy cool, ya que hay muchas páginas con información valiosa que no tienen una api publica

const puppeteer = require('puppeteer'); // Traemos el módulo puppeteer y IMPORTANTE añadir ; en todos los require porque
// me ha fallado porque no tenía el punto y coma, así que es preferible añadirlo como buena práctica para evitar errores

(async () => {
    console.log('Lanzamos navegador!');
    // const browser = await puppeteer.launch() // puppeteer.launch() nos sirve para lanzar el navegador ( abrir el navegador ) pero no lo abre de forma visual
    const browser = await puppeteer.launch({ headless: false }) // Y cambiando el headless a false lo que le decimos, es que se abra de forma visual

    const page = await browser.newPage() // browser.newPage() sirve para crear una nueva página a la que podemos añadirle la URL a la que queremos acceder

    await page.goto('https://es.wikipedia.org/wiki/Node.js') // Aquí usamos .goto(URL) que es igual a: go to = Ir a ... ( y añadimos la URL )

    var titulo = await page.evaluate(() => { // .evaluate(cb) va a ejecutar un script dentro de la páigna y va a devoler lo que toque
        const h1 = document.querySelector('h1') // cojemos el h1 de la página a la que vamos a acceder ( el código entero es lo que estamos recogiendo )
        console.log(h1.innerHTML) // le añadimos al h1 el atributo .innerHTML para que nos de el texto en concreto ( si es lo que deseamos )

        return h1.innerHTML // lo retornamos para almacenarlo en la variable titulo que hemos creado
    })

    console.log(titulo) // hacemos visible en el servidor el título (h1) de la web a la que hemos accedido

    console.log('Cerramos navegador...')
    browser.close()  // browser.close() nos sirve para cerrar el navegador desde el código
    console.log('Navegador cerrado')
})()

// es importante destacar que todos los llamados tienen un await para esperar a que hagan su función
// con el módulo puppeteer podemos ejecutar todo lo que queramos dentro del navegador y
// recojer lo que queramos y lo llevamos a dónde queramos

buscar nodejs en google

const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch({headless: false});
  
  const page = await browser.newPage();
  await page.goto('https://www.google.com/');

  await page.evaluate(() => {
    const input = document.querySelector('input');
    input.value = 'nodejs'
  })
  await page.keyboard.press('Enter');

  await delay(10000)
  browser.close();
})()

function delay(time) {
  return new Promise((resolve) => { 
      setTimeout(resolve, time)
  });
}

Estoy comenzando en este mundo y me gustaria saber que usos tiene el Web Scrapping?

No me funciono el ejemplo, creo cambio la forma de ejecutarse, me salio así

const puppeter = require('puppeteer');

(async () => {
  console.log('Lanzamos navegador');
  try {
    //   { headless: false }
    const browser = await puppeter.launch();

    const page = await browser.newPage();
    await page.goto('https://es.wikipedia.org/wiki/Node.js');

    var titulo1 = await page.$$eval('h1', (e) => {
      return e[0].innerHTML;
    });

    console.log(titulo1);
    console.log('Cerramos navegador.....');
    browser.close();
    console.log('navegador cerrado');
  } catch (error) {
    console.error(error);
  }
})();

Con puppeteer también se puede generar screenshots, aquí un ejemplo sencillo

const puppeteer = require('puppeteer');

(async () => {
    console.log('Lanzamos navegador!');
    const browser = await puppeteer.launch({args: ['--no-sandbox', '--disable-setuid-sandbox']});

    const page = await browser.newPage();
    await page.goto('https://unsplash.com/photos/wfBvrhoZtLs');
    await page.screenshot({ path: 'image.png' });

    console.log('Cerramos navegador...');
    await browser.close();
    console.log('Navegador Cerrado');
})();

En Mac 10.15.7 no me estaba abriendo el navegador hasta que agregué el siguiente parámetro al método launch:

    const browser = await puppeteer.launch({
        headless: false,
    });

headless por defecto es true, y cuando lo pasamos a false podemos ver más de cerca lo que sucede al abrir el navegador

Para quienes tengan WSL deben revisar la documentanción de puppeteer y revisar que tengan todas las dependencias instaladas, esto les puede generar problemas, además es posible que tengan que instalar chromiun diréctamente.

npm i puppeteer

Estimados, al ejecutar index.js me sale este error

internal/modules/cjs/loader.js:783
    throw err;
    ^

Error: Cannot find module '/mnt/c/Users/Cristobal/Documents/Cursos programación/Curso_de_Fundamentos_de_Node.js/herramientas/scrapping/idex.js'
    at Function.Module._resolveFilename (internal/modules/cjs/loader.js:780:15)
    at Function.Module._load (internal/modules/cjs/loader.js:685:27)
    at Function.Module.runMain (internal/modules/cjs/loader.js:1014:10)
    at internal/main/run_main_module.js:17:11 {
  code: 'MODULE_NOT_FOUND',
  requireStack: []
}```

Que debo hacer para solucionarlo?

Me encanto!!! Chromium nombre de pelicula!!! saldra la serie Chromium by Platzi? Sere yo un bug dentro de la App? jajaja excelente clase!

/* Scraping es una herramienta que que simula el uso de un navegador chrome */

/* npm i puppeteer asi instalamos herramienta de Scraping */

/* Asi podemos entrar a una web por medio de el navegador chrome y trabajar con la  informacion de ella */

const puppeteer = require('puppeteer');

(async () => {
    console.log('Lanzamos navegador!');
    /* const browser = await puppeteer.launch(); */
    const browser = await puppeteer.launch( { headless: false });
    

    const page = await browser.newPage();
    await page.goto('https://es.wikipedia.org/wiki/Node.js');

    var titulo1 = await page.evaluate(() => {
        const h1 = document.querySelector('h1');
        console.log(h1.innerHTML);

        return h1.innerHTML;
    });

    console.log(titulo1);

    console.log('Cerramos navegador...');
    browser.close();
    console.log('Navegador cerrado');
})();

🔥🔥🔥

Web scraping es una técnica utilizada mediante programas de software para extraer información de sitios web.

Wow… ya me estoy dando cuenta de la importancia de la accesibilidad. Usar las etiquetas HTML adecuadas, aria-labels y demás.

¿caul es el curso de scaraping?
Porfa link

npm install puppeteer

puppeteer es muy buena

MUY BUENA CLASE!!

Extracción de datos en la web con puppeteer

npm i puppeteer

Si!!! funciones autoejecutadas!!! Como me encantan.

Excelente profesor muy buen curso

Lo que hizo el profe en los primero minutos
es inmediatamente invocar a la función anónima, mejor conocida por
IIFE (Immediately Invoked Function Expression)

solo que el profe usó async, les dejo el link para que tengan mas conocimiento

https://developer.mozilla.org/en-US/docs/Glossary/IIFE

Super interesante

// Scraping

// Es la tecnica de simular la navegacion de un humano para extraer informacion de sitios

const puppeteer = require('puppeteer')
    // Funcion para navegar
async function scraping() {
    console.log('Lanch');
    // puppeter nos ayuda a abrir un navegador en segundo plano
    const browser = await puppeteer.launch({headless: false});
    // Abrir una nueva pagina
    const page = await browser.newPage();
    // Dirigir al navegador a una pagina
    await page.goto('https:es.wikipedia.org/wiki/node.js')
    // Busca el componente especifico y hace lo que se le indique
    var tittle1 = await page.evaluate(() => {
        const h1 = document.querySelector('h1');
        console.log(h1.innerHTML);
        return h1.innerHTML;
    });
    console.log(tittle1)
    console.log('Closing');
    browser.close();
    console.log('closed');
};

scraping()

Tengo 2 artículos sobre scraping; pienso que podría ser interesante, los dejo acá:

• Scraping de imágenes

• Scraping de GitHub

Las funciones que se auto-ejecutan se llaman IIFE (Immediately invoked function expression)

Para scraping, un framework interesante es selenium, soporta Python y javascript. Sirve para todo lo relacionada con la automatización de procesos en navegadores web Selenium

it is a magic

Me parece maravilloso como este curso me ha abierto la mente a un montón de conceptos y utilidades de Node.js que no tenía idea que existían.
Sobretodo genera muchas ideas para proyectos y mucha emoción por realizarlos 🤩.

Obteniendo la TRM Cotizada Semanalmente por la DIAN con puppeter

const puppeteer = require('puppeteer');

(async ()=>{
    //Instructions
    console.log('Launch Browser!');
    const browser = await puppeteer.launch({ headless: false});
    const page = await browser.newPage();
    await page.goto('https://www.dian.gov.co/dian/cifras/Paginas/TRM.aspx');


    let dian_general_url = await page.evaluate(()  => {
        const element = document.querySelector('.trm-link');
        console.log(element.href);
        return element.href;
    });

    getUsdValue(dian_general_url);
    
    console.log(dian_general_url)
    console.log('Finishing Browser!');
    browser.close();
    console.log('Browser is closed!');
})();


async function getUsdValue(dian_general_url){
    
    //Instructions
    console.log('Launch Browser!');
    const browser = await puppeteer.launch({ headless: false});
    const page = await browser.newPage();
    await page.goto(dian_general_url);

    let usd_value = await page.evaluate(()  => {
        const element1 = document.querySelector('.dollarValue');
        console.log(element1);
        return element1.innerHTML;
    });

    console.log('DIAN TRM USD '+usd_value)
    console.log('Finishing Browser!');
    browser.close();
    console.log('Browser is closed!');

    return usd_value;
};

Estos cursos están asociados a puppeteer

• Curso de Introducción a Automatización de Pruebas con Puppeteer
  https://platzi.com/cursos/puppeteer/

• Curso Avanzado de Automatización de Pruebas con Puppeteer
  https://platzi.com/cursos/puppeteer-avanzado/

Para que un profe tan Pro como Carlos se emocione contándonos que el curso que recomienda está buenisimo es que en realidad esta buenísimo.

Increible!!, creo que es la clase que mas me ha gustado del curso. Anteriormente ya conocia un poco sobre web scraping pero jamás imagine lo sencillo que puede llegar a ser obtener cierta información de donde sea que queramos 😃

Me pasó que no había puesto los paréntesis al final de la función auto-invocada.

Dejo esto por acá por si a alguien le sucede lo mismo.

Scraping

Herramienta

Puppeteer

1. Lo primero que se debe hacer es inicializar un proyecto de npm .

   npm init -y
   

2. Luego instalar el módulo puppeteer.

   npm i puppeteer
   

   Esto debe hacer la instalación de Chromium, que es la base del navegador Google Chrome y de muchos navegadores. Esto va a permitir que el módulo funcione correctamente.

3. Crear un archivo de index.js y dentro de este requerir el módulo puppeteer .

   const puppeteer = require('puppeteer')
   

   Este módulo funciona enteramente de forma asíncrona.

4. Funciones Auto-ejecutadas: se encierra una función anónima dentro de () paréntesis y se ejecuta poniendo () paréntesis después de esta.

   /*FUNCIÓN AUTO-EJECUTADA*/
   (async () => {
     // Code
   })()
   

5. Para iniciar un Navegador:

   (async () => {
     // Code
     console.log('Throw Browser');
     // const browser = await puppeteer.launch();
     const browser = await puppeteer.launch({headless: false});
   
     const page = await browser.newPage()
     await page.goto('https://es.wikipedia.org/wiki/Node.js')
   })();
   

   1. el método .launch() , permite lanzar el navegador. Si no se pasan argumentos, el navegador va a ser lanzado sin mostrar la aplicación como tal. Pero si se pasa {headless: false} , el navegador si se va a mostrar (ejecutar).
   2. el método browser.newPage() , permite abrir una nueva página en el navegador.
   3. el método browser.newPage().goto() , permite dirigir esa nueva página a un enlace específico.

6. Para cerrar el Navegador:

   (async () => {
     // Code
     console.log('Throw Browser');
     // const browser = await puppeteer.launch();
     const browser = await puppeteer.launch({headless: false});
   
     const page = await browser.newPage()
     await page.goto('https://es.wikipedia.org/wiki/Node.js')
   
     console.log('Closing Browser...');
     browser.close();
     console.log('Browser Close');
   })();
   

   1. el método .close() , permite cerrar el navegador que fue previamente abierto.

7. Ejecutar un script para devolver un h1 .

   var title1 = await page.evaluate(() => {
       const h1 = document.querySelector('h1');
       console.log(h1.innerHTML);
       return h1.innerHTML;
     });
   
   console.log(title1)
   

   1. page.evaluate() ejecuta un script dentro de la página que tenemos abierta y devuelve lo que le asignamos.
   2. document.querySelector('h1') permite obtener un objeto del DOM, en este caso un h1 .

Curso recomendado

Web Scraping - Platzi

Yo lleve un curso de web scrapping con Pythong y es muy bueno para probar tu aplicación web

página utlizada para el ejemplo:
‘https://es.wikipedia.org/wiki/Node.js’

const puppeteer = require('puppeteer');

(async () => {
    console.log('Lanzando navegador');
    //const browser = await puppeteer.launch();
    const browser = await puppeteer.launch( {headless: false });
    
    const page = await browser.newPage();
    await page.goto('https://es.wikipedia.org/wiki/Node.js')
    
    var titulo1 = await page.evaluate(() => {
        const h1 = document.querySelector('h1');
        console.log(h1.innerHTML);
        return h1.innerHTML;
    });

    console.log(titulo1);

    console.log('Cerrando navegador');
    browser.close();
    console.log('Navegador cerrado');
    
})();

Me encanto aprender a hacer Scraping!!!

Pero el curso de Web Scraping de Platzi es con Python no?

Que bonito es lo bonito!

Buena info aquí: https://developers.google.com/web/tools/puppeteer

función asíncrona

// npm init -y
// npm install puppeteer

Puppeteer

Me encantó esta clase

Muy interesante el tema del scrapping entiendo que puede ser muy util para aplicaciones de tipo SEO

Alguien sabe por qué sale esto?
![](

wow, creo que ahora si me animare a hacer el curso de web ascrapping!!

tengo una pregunta digamos nesecito dejar un dato en la pagina que visito para luego tomar los datos que quiero esto es posible con node

Si les da error al ejecutar nodemon index.js, sigan las intrucciones que están el está página:
https://github.com/puppeteer/puppeteer/issues/3443

Si están teniendo problemas para crear su package.json usen el comando completo
npm init -y

😃

Waoo, Genial

Voy de nuevo, no es el curso con los ejemplos mas grandiosos del mundo, pero vaya que le he entendido muchisimo

Esto es I N C R E I B L E!!!

Wow! Increìble!