Node- Clase 13 #106

Se subió código de la última semana NODE

Co-Authored-By: Carolina Mamani <111472448+CarolinaMamani@users.noreply.github.com>
Co-Authored-By: Augustonc <73897032+Augustonc@users.noreply.github.com>
Co-Authored-By: JohanaMM <89425234+JohanaMM@users.noreply.github.com>
Co-Authored-By: Marita <113071029+MARITACAMPOS@users.noreply.github.com>
Co-Authored-By: David <110946400+David-Esteche@users.noreply.github.com>
Co-Authored-By: Ciro Valentin Martinez Gonzalez <98560604+CiroValentinMartinezG@users.noreply.github.com>
Co-Authored-By: Pintos Araceli <111717735+AraceliPintos@users.noreply.github.com>

Node/Semana13/02-Fundamentos_node/async/asyncAwait.js

@@ -0,0 +1,98 @@
+//La palabra async NO es necesaria en las funciones porque ya son asíncronas
+//Igual, proyectan una sincronia visual
+async function hola(nombre) { //convertimos la funcion hola en una función asyncrona declarada.
+    return new Promise(function (resolve, reject) {
+        setTimeout(function () {
+            console.log('Hola ' + nombre);
+            resolve(nombre);
+        }, 1000);
+    })
+}
+
+
+
+async function hablar(nombre) {
+    return new Promise((resolve, reject) => { // usamos la sintaxis ES6
+        setTimeout(function () {
+            console.log('bla bla bla');
+            resolve(nombre);
+        }, 1000);
+    });
+}
+
+//Función asincrona - adios
+//await solamente es válido dentro de una función asíncrona.
+async function adios(nombre) {
+    return new Promise((resolve, reject) => {
+        setTimeout(function () {
+            console.log('Adiós ' + nombre); //forma correcta de concatenar
+            resolve();
+            //reject('Hay un error');
+        }, 1000);
+    });
+}
+
+//await hola('Ariel'); // esto es una mala syntaxis no se debe utilizar
+//await es válido solo dentro de una función asíncrona
+async function main() {
+    let nombre = await hola('ArielElProfe');
+    await hablar();
+    //sin el await se manejan en segundo plano
+    await hablar();
+    await hablar();
+    await adios(nombre);
+    console.log('Termina el proceso...');
+
+}
+
+//async await convierte las promesas en procesos aparentemente s+incronos
+
+//console.log('Empezamos el proceso...');
+
+main();
+
+//console.log('Esta va a ser la segunda instrucción');
+
+
+//TODO EL CÓDIGO EN INGLÉS
+function sayHello(name) {
+    return new Promise((resolve, reject) => { // usamos la sintaxis ES6
+        setTimeout(function () {
+            console.log('Hello ' + name);
+            resolve(name);
+        }, 1000);
+    });
+}
+
+function talk(name) {
+    return new Promise((resolve, reject) => { // usamos la sintaxis ES6
+        setTimeout(() => {
+            console.log('bla bla bla');
+            resolve(name);
+        }, 1000);
+    });
+}
+
+function sayBye(name) {
+    return new Promise((resolve, reject) => {
+        setTimeout(() => {
+            console.log('Goodbye ' + name); //forma correcta de concatenar
+            resolve(name);
+            //reject('Hay un error');
+        }, 1000);
+    });
+}
+
+async function conversation(name) {
+    console.log('Code in Eenglish');
+    console.log('Starting async process...');
+    await sayHello(name);
+    await talk();
+    await talk();
+    await talk();
+    await sayBye(name);
+    console.log('Process completed')
+
+}
+
+conversation('Ariel');

Node/Semana13/02-Fundamentos_node/async/callback.js

@@ -0,0 +1,26 @@
+
+function hola(nombre, miCallback){
+    setTimeout( function() {
+        console.log('Hola ' + nombre);
+        miCallback(nombre);
+    }, 1000);
+}
+
+//Función asincrona - adios
+function adios(nombre, otrocallback) {
+    setTimeout(function(){
+        console.log('Adiós '+ nombre);
+        otrocallback();
+    }, 1500);   
+}
+
+console.log('Iniciando el proceo...');
+
+hola('Carlos', function(nombre) {
+    adios(nombre, function(){
+        console.log('Terminando el proceso...');    
+    });
+});
+
+//hola('Carlos', function(){});
+//adios('Carlos', function(){});

Node/Semana13/02-Fundamentos_node/async/callbackHell.js

@@ -0,0 +1,60 @@
+
+function hola(nombre, miCallback) {
+    setTimeout(function () {
+        console.log('Hola ' + nombre);
+        miCallback(nombre);
+    }, 1000);
+}
+
+function hablar(callbackHablar) {
+    setTimeout(function () {
+        console.log('bla bla bla');
+        callbackHablar();
+    }, 1000);
+}
+
+//Función asincrona - adios
+function adios(nombre, otrocallback) {
+    setTimeout(function () {
+        console.log('Adiós ' + nombre);
+        otrocallback();
+    }, 1500);
+}
+
+//Función recursiva
+function conversacion(nombre, veces, callback){
+    if (veces > 0){
+        hablar(function() {
+            conversacion(nombre, --veces, callback);
+        });
+    } else{
+        callback(nombre,callback);
+    }
+}
+
+//--Proceso principal
+console.log('Iniciando el proceso...');
+hola('Ariel', function(nombre){
+    conversacion(nombre, 4, function(){
+        console.log('Terminando el proceso...');
+    });
+});
+
+/*
+Se comenta el codigo
+callback hell -> bienvenidos al infierno
+hola('Carlos', function (nombre) {
+    hablar(function () {
+        hablar(function () {
+            hablar(function () {
+                hablar(function () {
+                    adios(nombre, function () {
+                        console.log('Terminando el proceso...');
+                    });
+                });
+            });
+        });
+    });
+});
+
+*/

Node/Semana13/02-Fundamentos_node/async/promises.js

@@ -0,0 +1,64 @@
+/*
+Las promesas son una sintaxis mas elegible a realizar que los callbacks creando un codigo mas escalable
+Una promesa no deja de ser un callback, con la novedad de tener estados. Cuenta con tres estados: Resuelta, en progresoy en fallo.
+Las promesas dan un estado, son una clase global que podemos llamar de donde sea. HAcemos que nuestras funsciones devuelvan promesas. 
+La diferencia entre promise y callbacks es la capacidad de anidar promesas formando una cadena, muy util para visualizar codigo asincrono.
+Para utilizarla solo debemos instanciar una nueva, una promesa en si es una funcion que recibe dos parametros, el de Resolve y Reject que son los dos estados de una promesa.
+Utilizamos Resolve para retornar el valor deseado cuando una funcion se ejecute.
+Utilizamos Reject cuando una funcion retorna un valor no deseado, podriamos hablar de hasta un error.
+Para poder obtener los valores que retorna una funcion debemos utilizar su propiedad ".dem".
+Esta propiedad es una fincion que recibe un callback que tendra como parametro el valor retornado con Resolve, retorna la respuesta de lo que ah resuelto, 
+O lo que es Reject, rechazar, estos dos parametros son funciones dentro de lo que es la promesa.
+Siempre de que usemos la promesa ademas de realizar la propiedad o metodo que en este caso seria el ".dem" debemos invocar otra propiedad que es el ".catch" la cual es un callback que recibe comom parametro el error ocurrido en caso de que aya susedido uno.
+*/
+
+function hola(nombre) {
+    return new Promise(function (resolve, reject) {
+        setTimeout(function () {
+            console.log('Hola ' + nombre);
+            resolve(nombre);
+        }, 1000);
+    })
+}
+
+
+//TEORIA DE CLASE 11 - NODE JS
+
+//Término 'azucar sintáctico': Introducido por Peter J Landin en 1964 para referirse a los añadidos de la sintaxis
+//para facilitar a los programadores entender lo complejo
+//Al expresar de esta forma mas clara/alternativa la sintaxis del lenguaje sin afectar la funcionalidad del programa.
+
+function hablar(nombre) {
+    return new Promise( (resolve, reject) => { // usamos la sintaxis ES6
+        setTimeout(function () {
+            console.log('bla bla bla');
+            resolve(nombre);
+        }, 1000);
+    });
+}
+
+//Función asincrona - adios
+function adios(nombre) {
+    return new Promise((resolve, reject) => {
+        setTimeout(function () {
+            console.log('Adiós ' + nombre); //forma correcta de concatenar
+            //resolve();
+            reject('Hay un error');
+        }, 1000);
+    });
+}
+
+//llamamos a la función
+console.log('Iniciando el proceso...');
+hola('Ariel')
+    .then(hablar)
+    .then(hablar)
+    .then(hablar)
+    .then(adios) //.then retorna un valor
+    .then((nombre) => {
+        console.log('Terminando el proceso');
+    })
+    .catch(error => {
+        console.log('Ha habido un error: ');
+        console.log(error);
+    })

Node/Semana13/02-Fundamentos_node/modulos/archivo.txt

@@ -0,0 +1,5 @@
+Hola a toda la tecnicatura;
+
+Ahora es el momento de decirles;
+
+Los felicito, estamos terminando!!!

Node/Semana13/02-Fundamentos_node/modulos/fs.js

@@ -0,0 +1,5 @@
+// traemos el módulo de file system
+// sirve para trabajar y manipular archivos de nuestro sistema
+
+const fs = require('fs'); //ya viene instalado en el core de Node
+

Node/Semana13/02-Fundamentos_node/modulos/globales.js

@@ -0,0 +1,41 @@
+// this === global = true
+
+// mostrar algo en consola
+//console.log(); // es un módulo
+
+// mostrar un mensaje en forma de error
+//console.error();
+
+
+// ejecutar un código despues de un intervalo de tiempo
+//setTimeout(()=>{});
+
+// ejecutar un código cada intervalo de tiempo
+//setInterval(()=>{});
+
+// da prioridad de ejecución a una función asíncrona
+// se ejecuta una vez que termina el hilo principal
+// solo es soportado por internet explorer versión 10
+//setImmdiate();
+
+//console.log(global);
+//console.log(setInterval); // es una función
+
+
+
+let i = 0;
+let intervalo = setInterval(() => {
+    console.log('Hola');
+    if (i ===3){ 
+    clearInterval(intervalo); //detenemos la funcion
+}
+i++;
+}, 1000);
+
+setImmediate(() => {
+    console.log(`Saludo inmediato`);
+});
+
+//require();
+
+console.log(__filename);