Añadimos algo que puede interesar aprender/retener

05. modulos/modulos.js

@@ -2,9 +2,11 @@ var path = require('path');
 var util = require('util');
 var v8 = require('v8');
 
+// console.log(path.basename(__filename)); // path.basename quita de un path (como __filename) la ruta y sólo deja el nombre del fichero
 //console.log(path.join(__dirname, 'www', 'img', 'home', 'uploads'));
 var nombre = "Marcos";
 var edad = 25;
 var texto = util.format("Hola %s, tienes %d años", nombre, edad);
 
+console.log(texto);
 console.log(v8.getHeapStatistics());

06. readline/readline.js

@@ -8,12 +8,14 @@ var persona = {
     comentarios: []
 };
 
+function askByComentary() {
+  rl.setPrompt('Dime un comentario: ');
+  rl.prompt();
+}
+
 rl.question('Cuál es tu nombre? ', (respuesta) => {
     persona.nombre = respuesta;
-
-    rl.setPrompt('Dime un comentario: ');
-    rl.prompt();
-
+    askByComentary();
 });
 
 rl.on('line', (input) => {
@@ -22,13 +24,12 @@ rl.on('line', (input) => {
         console.log(mensaje);
         process.exit();
     }
-    persona.comentarios.push(input.trim());
 
-    rl.setPrompt('Dime un comentario: ');
-    rl.prompt();
+    persona.comentarios.push(input.trim());
+    askByComentary();
 });
 
-const request = https.request(options, (res) => {
+/* const request = https.request(options, (res) => {
             context.log(`statusCode: ${res.statusCode}`);
 
   res.on('data', (d) => {
@@ -41,4 +42,4 @@ request.on('error', (error) => {
   context.error(error);
 });
 
-request.end();
+request.end(); */

07. eventos/eventos.js

@@ -1,11 +1,11 @@
-const eventEmitter = require('events').EventEmitter;
+const eventEmitterA = require('events').EventEmitter;
 const util = require('util');
 
 var Persona = function(nombre){
     this.nombre = nombre;
 }
 
-util.inherits(Persona, eventEmitter);
+util.inherits(Persona, eventEmitterA);
 
 let persona = new Persona('Bob');
 
@@ -17,6 +17,32 @@ persona.on('hablar', (mensaje) => {
 
 persona.emit('hablar', 'Hoy es un gran día');
 
+
+// ********************************************************************************************* //
+// ** Esto lo ponemos porque el método inherits de util está deprecated                       ** //
+// ********************************************************************************************* //
+const EventEmitter = require('events');
+
+// Creamos la clase MyStream que extenderá de la constante EventEmitter que cargo events
+class MyStream extends EventEmitter {
+  escribir(data) {
+    this.emit('jopla', data); // Le pedimos a node que escuche lo que le envío al evento jopla
+  }
+}
+
+const stream = new MyStream();
+
+// Le decimos a la constante stream que escuche por el evento 'jopla'
+stream.on('jopla', (data) => {
+  console.log(`Received data: "${data}"`);
+});
+
+// Llamamos al evento jopla mediante el método escribir
+stream.escribir('With ES6');
+
+
+
+
 /*
 emitter.on('eventoCustom', (mensaje, estatus) => {
 

09. Ejecutar procesos/ejecutar.js

@@ -3,11 +3,22 @@ const exec = require('child_process').exec
 const x = 10;
 const y = 15;
 
+/* 
 exec('./script.sh ' + x + ' ' + y, (err, stdout) =>{
     if(err){
         throw err;
     }
 
+    console.log('Comando ejecutado');
+    console.log(stdout);
+});
+ */
+
+exec('ls', (err, stdout) =>{
+    if(err){
+        throw err;
+    }
+
     console.log('Comando ejecutado');
     console.log(stdout);
 });

09. Ejecutar procesos/script.sh

@@ -0,0 +1,4 @@
+((suma = $1 + $2))
+
+echo "El inicio de un bash"
+echo "La suma es $suma"

10. leer archivos/leer.js

@@ -1,21 +1,32 @@
 var fs = require("fs");
 
-//var files = fs.readdirSync('./');
+// Esta es una lectura del directorio y no pasa hasta la siguiente línea (console.log) sin que termine de leer todo el directorio
+// var files = fs.readdirSync('./'); Rellena files con lo que hay en el directorio ./
+// console.log(files);
+
+// Ahora va a hacer una lectura asíncrona, deja el proceso trabajando y continua con lo que hubiera después
 fs.readdir('./', (error, files) => {
 
     if(error){
         throw error;
     }
-    console.log(files);
 
-    //var archivo = fs.readFileSync('./archivo.txt', 'UTF-8');
+    console.log(files); // Nos presenta el contenido del directorio actual ./
+
+
+    //var archivo = fs.readFileSync('./archivo.txt', 'UTF-8'); Lectura continua, no pasa a la siguiente línea hasta que no termina
 
+    // Lectura paralela del fichero ./archivo.txt ... console.log('Contenido del archivo...'); ... se ejecuta antes de que termine de abrir y leer el fichero
     fs.readFile('./archivo.txt','UTF-8', (error, archivo) => {
         if(error){
             throw error;
         }
         console.log(archivo);
     });
+
     console.log('Contenido del archivo...');
 });
 
+// Pero se aconseja usar steams cuando estemos usando ficheros con tamaños muy grandes
+// Además permite no solo leer texto, sino también cualquier tipo de bytes de un fichero
+

11. escribir archivos/escribir.js

@@ -21,10 +21,11 @@ const archivo = 'prueba.txt';
 //escribir en un archivo
 const contenido = 'Este es el contenido de un texto';
 
+// Crea el archivo de una manera síncrona
 //fs.writeFileSync(archivo, contenido);
 //console.log('Se ha escrito en el archivo');
 
-//asíncrona
+// Crea el archivo de una manera asíncrona
 /*fs.writeFile(archivo, contenido, (err) =>{
     if(err) throw('Hubo un error al escribir en el archivo');
 

11. escribir archivos/prueba.txt

@@ -1,2 +1,3 @@
 Este es el contenido de un texto
+Aquí va otra línea de código
 Aquí va otra línea de código

13. operaciones archivos/operaciones.js

@@ -14,6 +14,16 @@ const fs = require('fs');
     console.log('El archivo fue renombrado exitosamente...');
 }); */
 
+/* fs.rename('./config.txt', './prueba.txt', function (err) {
+    if(err){
+        throw(err);
+    }
+
+    console.log('El archivo fue renombrado exitosamente...');
+});
+ */
+
+
 // mover archivo 📂 ➡️ 📂
 /* fs.rename('./prueba.txt', './src/prueba.txt', (err)=>{
     if(err){
@@ -24,6 +34,26 @@ const fs = require('fs');
 }); */
 
 
-// eliminar archivo ❌
+/* // eliminar archivo - síncrono ❌
 fs.unlinkSync('./src/prueba.txt');
-console.log('El archivo ha sido eliminado');
+console.log('El archivo ha sido eliminado'); */
+
+// eliminar archivo - asíncrono ❌
+if(fs.existsSync('./src/prueba.txt')){
+    fs.unlink('./src/prueba.txt', (err)=>{
+        if (err) {
+            throw(err);
+        }
+        console.log('El archivo ha sido eliminado');
+    });
+}
+
+// Borrado de directorio si existe - asíncrono, con comprobación de su existencia síncrona
+if(fs.existsSync('src')){
+    fs.rmdir('src', function(err){
+        if(err){throw(err);}
+        console.log('La carpeta ha sido borrada ... 😎');
+    });
+}else{
+    console.log('La carpeta no existe... 😧');
+}

15. escribir streams/escribir-streams.js

@@ -5,18 +5,19 @@ let i = readline.createInterface(process.stdin, process.stdout);
 
 i.question('Cuál es tu nombre? > ', (nombre)=>{
 
+    //fs.writeFileSync(`./${nombre}.txt`, `Esto dijo ${nombre} \n`);
     let stream = fs.createWriteStream(`./${nombre}.txt`);
     stream.write(`Esto dijo ${nombre} \n`);
-    //fs.writeFileSync(`./${nombre}.txt`, `Esto dijo ${nombre} \n`);
+
     process.stdout.write('Qué quieres decir? \n');
 
     i.on('line', (dicho)=>{
         if(dicho.trim() == 'salir'){
             stream.close();
             i.close();
         }else{
-            stream.write(dicho.trim() + '\n');
             //fs.appendFileSync(`./${nombre}.txt`, dicho.trim() + '\n');
+            stream.write(dicho.trim() + '\n');
         }
     });
 });

16. ejercicio01/tutorial/app.js

@@ -22,8 +22,8 @@ const pantalla = `
 mainScreen();
 
 function mainScreen(){
-    process.stdout.write('\033c');
-
+    process.stdout.write('\033c'); // Para vaciar la pantalla / tipo clear ó CLS
+    
     interface.question(pantalla, res => {
         switch(res.trim()){
             case '1':

16. ejercicio01/tutorial/directory.js

@@ -22,14 +22,16 @@ class Directory{
     }
 
     getShortPath(){
-        const paths = path.parse(this._path);
-        let delimiter = '/';
+        const paths = path.parse(this._path); // path.parse lo que hace es desintegrar (separar por bytes) this._path (__dirname)
+        let delimiter = '/'; // Primero designamos el separador de directorios con /
 
-        if(paths.dir.indexOf(delimiter) < 0){
-            delimiter = `\\`;
+        // Pero según el sistema operativo tengo que ver que si me devuelve / ó \ en windows
+        if(paths.dir.indexOf(delimiter) < 0){ // buscamos con indexOf si se encuentra el delimitador /
+            // No ha encontrado el delimitador /, por lo que el SO es windows
+            delimiter = `\\`; // Pongo dos barras invertidas porque si dejo una sóla es como si le dijeramos que va a ser un comando especial
         }
 
-        return `${paths.root}...${delimiter}${paths.name}`;
+        return `${paths.root}...${delimiter}${paths.name}`; // Devolvemos una manera más corta del path donde nos encontramos
     }
 
     getFilesInDir(){

18. servidor web/server.js

@@ -19,4 +19,5 @@ http.createServer((req, res) =>{
     </html>
     `);
 }).listen(3000);
+
 console.log('Servidor iniciado...');