Tutorial de lista de tareas pendientes de Node.js

En esta aventura de Node.js, abordaremos la aplicación obligatoria de lista de tareas pendientes. A lo largo del camino, aprenderemos sobre los conceptos básicos de los módulos y cómo usarlos en un entorno Node. Después de eso, exploraremos cómo usar require () para hacer uso tanto de nuestros propios archivos como de los módulos de terceros creados por la comunidad. Necesitaremos ver cómo aceptar la entrada del usuario, así como hacer uso de JSON para almacenar los datos que componen nuestros elementos de tareas pendientes. Comencemos a poner en funcionamiento nuestra aplicación de lista de tareas pendientes de Node.js ahora.

Ejecute un archivo JavaScript como una aplicación NodeJS

Ya aprendimos cómo escribir algunos comandos en la consola de Node y hacer que sucedan algunas cosas. Ahora, queremos crear archivos JavaScript que se puedan ejecutar como una aplicación Node.js. ¿Cómo podemos hacer esto? Comenzaremos con el ejemplo obligatorio de Hello World. Primero, crearemos un directorio en nuestra máquina para contener algunos archivos JavaScript.

C: \> nodo mkdir

Ahora, abriremos esa carpeta usando Visual Studio Code, un editor de código fantástico y poderoso que también es gratuito. Una vez abierto, continúe y cree un nuevo archivo de app.js como ese.
nuevo archivo de código de estudio visual

En el archivo app.js, agregaremos algún código y guardaremos el archivo si es necesario. (El código de Visual Studio se guardará automáticamente en la mayoría de los casos)
hola mundo nodo js

Ahora tiene una aplicación básica de Node.js que está lista para ejecutarse. Sé que apenas puedes contener tu emoción. ¡Ahora podemos ejecutar ese programa!
hola mundo en nodo

¡Salvaje! Sé que parece trivial, pero acabas de seguir los pasos básicos para crear una aplicación Node.js muy básica. Creamos un directorio para almacenar nuestros archivos de programa, agregamos algo de código y finalmente ejecutamos el programa. ¡Eso es practicamente todo! Incluso las aplicaciones más grandes y complejas comenzarán con estos primeros pasos simples.

Conceptos básicos del módulo en Node.js

Con nuestro ejemplo de hola mundo abordado, aprendamos un poco sobre los módulos en Node.js. Los módulos son unidades de funcionalidad. En Node hay todo tipo de módulos que puedes utilizar. Algunos lo ayudan a trabajar con el sistema de archivos, otros pueden proporcionar servicios http o servicios DNS.

require () para módulos integrados

Veamos cómo podemos hacer uso de un módulo en Node.js. Considere este código.

1
2
3
4
5
6
7
const fs = require('fs');
 
fs.appendFile('file.txt', 'Writing To The Filesystem! ', (error) => {
    console.log(error);
});
 
console.log('Data has been written to file.txt');

En este código, primero hacemos uso de la función require () del nodo. Se utiliza para requerir módulos en Node. La cadena 'fs' que pasamos a require () se carga en el módulo de sistema de archivos integrado de Node . Esto se almacena en el objeto fs, que ahora tiene una gran cantidad de métodos que puede utilizar. Para este ejemplo rápido, simplemente usaremos el método fs.appendFile () que agrega datos de forma asincrónica a un archivo, creando el archivo si aún no existe. El primer argumento es el nombre del archivo para escribir. Proporcionamos 'file.txt' como archivo. El siguiente argumento son los datos que se escribirán en ese archivo. Por último, debemos incluir una devolución de llamada para manejar cualquier error que pueda ocurrir. Antes de ejecutar el programa, así es como se ve el código de Visual Studio.
requirefs de nodo

Ahora podemos ejecutar la aplicación desde la línea de comandos escribiendo node app.js.

C: \ nodo> nodo app.js
Los datos se han escrito en file.txt
nulo

Una vez finalizado el programa, observe que ahora tenemos un nuevo archivo en nuestro editor de file.txt. Esto se debe a que Node.js acaba de crear el nuevo archivo y le escribió datos. ¡Muy genial!
archivo escrito por nodejs

Continúe y ejecute el programa una vez más, y verá que se agrega un segundo conjunto de datos al archivo.
escribiendo en el sistema de archivos

Si lo desea, puede ejecutar este programa 500 veces y almacenar el texto de "Escribiendo en el sistema de archivos". 500 veces en ese archivo de texto file.txt. Por supuesto, eso realmente no tiene sentido, pero ahora tenemos un ejemplo real de trabajo de requerir el fsmódulo en una aplicación Node y escribir datos en el sistema de archivos. ¡Excelente!

require () para tus propios módulos o archivos

Con Node y ES6, es muy fácil colocar código en archivos separados y luego importarlos según sea necesario. Esto limpia drásticamente su base de código y ayuda a mantener todo organizado de una manera muy ordenada para sus proyectos. A veces creo que la organización de código simple es literalmente la mitad de la batalla en la ingeniería de software. Entonces, en el espíritu de la aplicación de lista de tareas, creemos un nuevo archivo todos.js en nuestro editor y coloquemos el siguiente código en él.

todos.js

1
2
3
4
5
console.log('Running todos.js');
 
module.exports.addTodo = () => {
    return 'New Todo created.';
};

Aquí estamos exportando la función de flecha addTodo () . Simplemente agregamos una declaración de consola al archivo para mostrar cuándo se ejecuta este archivo durante la ejecución de la aplicación. Ahora mira esto. En el archivo app.js principal, ahora podemos requerir lo que se ha exportado desde todos.js.

1
2
3
4
5
6
7
console.log('Running app.js');
 
const fs = require('fs');
 
const todos = require('./todos.js');
 
console.log(todos.addTodo());

Ejecutar la aplicación nos muestra que todo está funcionando muy bien.
requieren sus propios archivos js

La mayoría de las veces, el objetivo de las exportaciones es poder exportar funciones que se utilizan en el archivo app.js principal.

Requerir módulos de terceros en su aplicación de nodo

Ahora queremos aprovechar lo mejor de Node.js. ¡Todo el maravilloso software que ya ha sido escrito para ti! Para hacer uso de módulos de terceros, primero debemos crear un archivo package.json . Podemos hacer esto fácilmente ejecutando el npm initcomando en la raíz del proyecto.

c: \ nodo> npm init
Esta utilidad lo guiará a través de la creación de un archivo package.json.
Solo cubre los elementos más comunes e intenta adivinar valores predeterminados razonables.

Consulte la npm help jsondocumentación definitiva sobre estos campos.
y exactamente lo que hacen.

Úselo luego para instalar un paquete ynpm install  --save
guárdelo como una dependencia en el archivo package.json.

Presione ^ C en cualquier momento para salir.
nombre: (nodo)

Como puede ver, comienza como un programa de shell en el que se nos presentan varias preguntas sobre la aplicación que está creando. Así es como completamos este pequeño cuestionario.

nombre: (nodo) todos-nodo
versión: (1.0.0)
descripción:
punto de entrada: (app.js)
comando de prueba:
repositorio git:
palabras clave:
autor: vegibit
licencia: (ISC)
A punto de escribir en c: \ node \ package.json:

{
  "nombre": "todos-nodo",
  "versión": "1.0.0",
  "descripción": "",
  "main": "app.js",
  "dependencias": {},
  "devDependencies": {},
  "guiones": {
    "prueba": "echo \" Error: no se especificó ninguna prueba \ "&& salida 1"
  },
  "autor": "vegibit",
  "licencia": "ISC"
}


¿Esta bien? (sí Sí

c: \ nodo>

Ahora tenemos un archivo package.json en nuestro proyecto. Con este archivo en su lugar, podemos comenzar a agregar módulos de terceros a nuestra aplicación. Comenzaremos agregando la popular biblioteca de utilidades de JavaScript Lodash escribiendo lo siguiente en el símbolo del sistema.

c: \ nodo> npm install lodash --save

Este comando hará un par de cosas por ti. En primer lugar, ahora actualizará su archivo package.json automáticamente con la dependencia que acaba de agregar. En segundo lugar, el software NPM se comunicará con los servidores, tomará el software que desea usar y lo colocará en su máquina en un nuevo directorio llamado node_modules . ¡Echale un vistazo!
npm instalar lodash

Lodash ahora se puede utilizar en su proyecto

Podemos actualizar nuestro archivo app.js principal para incorporar Lodash ahora.

app.js

1
2
3
4
5
6
7
8
console.log('Running app.js');
 
const fs = require('fs');
const _ = require('lodash');
 
const todos = require('./todos.js');
 
console.log(todos.addTodo());

¡Bingo! Eso es todo lo que se necesita para descargar e instalar un módulo de terceros en su proyecto Node.js. Tienes más de seiscientos mil (!) Para elegir, así que diviértete.

Reiniciar su aplicación Node.js con nodemon

A medida que construye su aplicación, necesitará retroceder continuamente y ejecutar manualmente la aplicación desde el terminal. ¡Eso no es realmente divertido, y podemos y debemos automatizar todas las cosas! Para que nuestra aplicación se reinicie automáticamente después de realizar cambios en nuestros archivos JavaScript, podemos instalar el popular módulo nodemon para que lo haga por nosotros. Sigamos adelante y agreguemos nodemon a nuestra máquina.

c: \ nodo> npm instalar nodemon -g

Una vez que nodemon está instalado, ahora puede ejecutar sus aplicaciones escribiendo nodemon <nombre de archivo> en lugar de nodo <nombre de archivo>. Echar un vistazo.
ejecutando nodemon

Lo que está sucediendo ahora es que nodemon ha puesto la aplicación en un estado de ejecución, pero siempre está monitoreando cualquier cambio. Si se detectan esos cambios, la aplicación se reiniciará automáticamente y podrá verla en tiempo real en la terminal. Hagamos un cambio en uno de nuestros archivos de aplicación. Simplemente agregaremos una declaración de registro simple a app.js así.

1
2
3
4
5
6
7
8
9
console.log('Running app.js');
 
const fs = require('fs');
const _ = require('lodash');
 
const todos = require('./todos.js');
 
console.log(todos.addTodo());
console.log('We Love Nodemon!');

Si te diriges a la terminal, ¡mira lo que vemos!

[nodemon] reiniciando debido a cambios ...
[nodemon] comenzando node app.js
[nodemon] reiniciando debido a cambios ...
Ejecutando app.js
Ejecutando todos.js
Nuevo Todo creado.
¡Amamos a Nodemon!
[nodemon] comenzando node app.js
Ejecutando app.js
Ejecutando todos.js
Nuevo Todo creado.
¡Amamos a Nodemon!
[nodemon] salida limpia - esperando cambios antes de reiniciar

Nodemon detectó cualquier cambio de inmediato y reinició la aplicación. Le encantará esta conveniencia a medida que desarrolla aplicaciones en Node.js.

Obteniendo entrada de usuario

Ahora finalmente podemos obtener alguna entrada del usuario. Así es como podremos agregar un elemento de tareas pendientes a la aplicación. Solo queremos configurar algo súper básico. Queremos que el usuario pueda escribir una tarea o un recordatorio en el sistema. Usaremos un módulo de Node.js llamado Yargs para ayudarnos con esto. Primero instalemos Yargs.

c: \ nodo> npm install yargs --save

Una vez que se instala, podemos requerirlo en nuestra aplicación como vemos aquí.

1
2
3
4
5
6
7
console.log('Running app.js');
 
const fs = require('fs');
const _ = require('lodash');
const yargs = require('yargs');
 
const todos = require('./todos.js');

Ahora haremos un par de adiciones aquí.

1
2
3
4
5
6
7
8
9
10
11
console.log('Running app.js');
 
const fs = require('fs');
const _ = require('lodash');
const yargs = require('yargs');
 
const todos = require('./todos.js');
 
const args = yargs.argv;
 
console.log(args.todo);

En el código anterior, recopilamos los argumentos de la línea de comandos proporcionados a través de yargs.argv y los almacenamos en args. Luego, vamos a cerrar la sesión de un argumento de 'todo' accediendo a él con args.to. Veamos eso en acción.
entrada de línea de comando yargs

Como podemos ver si ejecutamos app.js y pasamos algunos argumentos como lo hicimos aquí, podemos acceder a ellos dentro del programa. Al escribir node app.js --todo="eat lunch", estamos ejecutando app.js y pasando un argumento de todoy su valor es eat lunch.

Vamos a querer addTodo, listTodos, readTodo o deleteTodo. Necesitaremos capturar más información de la línea de comando para hacer eso. Podemos capturar la entrada de esa manera así:

1
2
3
4
5
6
7
8
9
10
11
console.log('Running app.js');
 
const fs = require('fs');
const _ = require('lodash');
const yargs = require('yargs');
 
const todos = require('./todos.js');
 
const args = yargs.argv;
 
console.log('You ran the command: ' + args._[0]);

c: \ nodo> nodo app.js addTodo
Ejecutando app.js
Ejecutando todos.js
Ejecutó el comando: addTodo

c: \ nodo> nodo app.js listTodos
Ejecutando app.js
Ejecutando todos.js
Ejecutó el comando: listTodos

c: \ nodo> nodo app.js readTodo
Ejecutando app.js
Ejecutando todos.js
Ejecutó el comando: readTodo

c: \ nodo> nodo app.js deleteTodo
Ejecutando app.js
Ejecutando todos.js
Ejecutó el comando: deleteTodo

Simplemente incluyendo el nombre del comando después de inicializar app.js, podemos ver que hemos capturado esa entrada y la estamos enviando a la consola.

Usar JSON para administrar datos

Necesitamos tener una forma de almacenar esos elementos de tareas pendientes en nuestra aplicación para que no se vayan flotando al abismo. Podemos hacer esto con JSON. Podemos comenzar configurando una forma de agregar un elemento de tarea.

Agregar un Todo

En primer lugar, actualice el archivo app.js así.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
console.log('Running app.js');
 
const fs = require('fs');
const _ = require('lodash');
const yargs = require('yargs');
 
const todos = require('./todos.js');
 
const argv = yargs.argv;
var command = argv._[0];
 
console.log('Running Command: ', command);
 
if (command === 'addTodo') {
    todos.addTodo(argv.title);
} else {
    console.log('Invalid command.');
}

Ahora necesitamos agregar algo de lógica al archivo todos.js para agregar realmente un elemento a un objeto de datos JSON.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
console.log('Starting todos.js');
 
const fs = require('fs');
 
var addTodo = (title) => {
    var todos = [];
    var todo = {
        title
    };
 
    try {
        var todosString = fs.readFileSync('todos-data.json');
        todos = JSON.parse(todosString);
    } catch (e) {
 
    }
 
    var duplicatetodos = todos.filter((todo) => todo.title === title);
 
    if (duplicatetodos.length === 0) {
        todos.push(todo);
        fs.writeFileSync('todos-data.json', JSON.stringify(todos));
    }
};
 
module.exports = {
    addTodo
};

Ok, creo que podemos ejecutar el programa. Aquí va:

c: \ node> node app.js addTodo --title = "Cortar el césped"
Ejecutando app.js
Iniciando todos.js
Comando en ejecución: addTodo

Si busca en Visual Studio Code, verá un nuevo archivo allí. Inspeccionar ese archivo nos muestra que la tarea que acabamos de agregar al sistema ahora está almacenada en ese archivo todos-data.json. ¡Frio!
datos almacenados en el archivo json

Agregaremos algunos elementos más.

c: \ node> node app.js addTodo --title = "Ir a trabajar"
Ejecutando app.js
Iniciando todos.js
Comando en ejecución: addTodo

c: \ node> node app.js addTodo --title = "Leer el documento"
Ejecutando app.js
Iniciando todos.js
Comando en ejecución: addTodo

c: \ node> node app.js addTodo --title = "Netflix y relajarse"
Ejecutando app.js
Iniciando todos.js
Comando en ejecución: addTodo

Efectivamente, nuestro archivo de datos json se está actualizando.

1
[{"title":"Mow the lawn"},{"title":"Go to work"},{"title":"Read the paper"},{"title":"Netflix and chill"}]

Las funciones que están haciendo el trabajo pesado por nosotros son las siguientes.

readFileSync

Lee sincrónicamente todo el contenido de un archivo.

@param path
Una ruta a un archivo. Si se proporciona una URL, debe utilizar el archivo: protocolo. La compatibilidad con URL es experimental. Si se proporciona un descriptor de archivo, el archivo subyacente no se cerrará automáticamente.
Opciones de @param: un objeto que puede contener una bandera opcional. Si no se proporciona una bandera, el valor predeterminado es 'r'.

JSON.parse

Convierte una cadena de notación de objetos JavaScript (JSON) en un objeto.

@param text: una cadena JSON válida.
@param reviver
Una función que transforma los resultados. Esta función se llama para cada miembro del objeto. Si un miembro contiene objetos anidados, los objetos anidados se transforman antes que el objeto principal.

writeFileSync

Escribe datos de forma sincrónica en un archivo, reemplazando el archivo si ya existe.

@param path
Una ruta a un archivo. Si se proporciona una URL, debe utilizar el archivo: protocolo. La compatibilidad con URL es experimental. Si se proporciona un descriptor de archivo, el archivo subyacente no se cerrará automáticamente.
@param data: los datos que se van a escribir. Si se proporciona algo que no sea Buffer o Uint8Array, el valor se convierte en una cadena.
Opciones de @param
O la codificación del archivo o un objeto que especifica opcionalmente la codificación, el modo de archivo y la marca. Si no se proporciona la codificación, se utiliza el valor predeterminado de 'utf8'. Si no se proporciona el modo, se utiliza el valor predeterminado 0o666. Si el modo es una cadena, se analiza como un entero octal. Si no se proporciona el indicador, se utiliza el valor predeterminado 'w'.

JSON.stringify

Convierte un valor de JavaScript en una cadena de notación de objetos de JavaScript (JSON).

@param value: un valor de JavaScript, generalmente un objeto o matriz, que se va a convertir.
@param replacer - Una función que transforma los resultados.
@param space: agrega sangría, espacios en blanco y caracteres de salto de línea al texto JSON de valor de retorno para facilitar la lectura.

Eliminar un elemento de Todo

Ahora agreguemos la lógica para eliminar un elemento de tarea del almacén de datos JSON. Nuestros archivos todos.js y app.js actualizados se encuentran a continuación.
todos.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
console.log('Starting todos.js');
 
const fs = require('fs');
 
// add a todo item //
var addTodo = (title) => {
  var todos = fetchTodos();
  var todo = {
    title
  };
 
  var duplicatetodos = todos.filter((todo) => todo.title === title);
 
  if (duplicatetodos.length === 0) {
    todos.push(todo);
    saveTodos(todos);
    return todo;
  }
};
 
// delete a todo item //
var deleteTodo = (title) => {
  var todos = fetchTodos();
  var filteredtodos = todos.filter((todo) => todo.title !== title);
  saveTodos(filteredtodos);
 
  return todos.length !== filteredtodos.length;
};
 
// utility functions
var fetchTodos = () => {
  try {
    var todosString = fs.readFileSync('todos-data.json');
    return JSON.parse(todosString);
  } catch (e) {
    return [];
  }
};
 
var saveTodos = (todos) => {
  fs.writeFileSync('todos-data.json', JSON.stringify(todos));
};
 
// exported functions
module.exports = {
  addTodo,
  deleteTodo
};

app.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
console.log('Running app.js');
 
const fs = require('fs');
const _ = require('lodash');
const yargs = require('yargs');
 
const todos = require('./todos.js');
 
const argv = yargs.argv;
var command = argv._[0];
 
console.log('Running Command: ', command);
 
if (command === 'addTodo') {
    todos.addTodo(argv.title);
} else if (command === 'deleteTodo') {
    var todoDeleted = todos.deleteTodo(argv.title);
    var message = todoDeleted ? 'Todo was deleted' : 'Todo not found';
    console.log(message);
} else {
    console.log('Invalid command.');
}

Ahora podemos ejecutar el programa pasando un título que sabemos que existe y uno que no para confirmar que todo funciona correctamente.

c: \ node> node app.js deleteTodo --title = "Netflix y relájate"
Ejecutando app.js
Iniciando todos.js
Comando en ejecución: deleteTodo
Todo fue eliminado

c: \ node> node app.js deleteTodo --title = "Ver Pulp Fiction"
Ejecutando app.js
Iniciando todos.js
Comando en ejecución: deleteTodo
Todo no encontrado

Leer un artículo de Todo

Esta iteración agregará la capacidad de simplemente leer un elemento de tarea pendiente cuando pasamos el título de ese elemento de tarea.
app.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
console.log('Running app.js');
 
const fs = require('fs');
const _ = require('lodash');
const yargs = require('yargs');
 
const todos = require('./todos.js');
 
const argv = yargs.argv;
var command = argv._[0];
 
console.log('Running Command: ', command);
 
if (command === 'addTodo') {
    todos.addTodo(argv.title);
} else if (command === 'deleteTodo') {
    var todoDeleted = todos.deleteTodo(argv.title);
    var message = todoDeleted ? 'Todo was deleted' : 'Todo not found';
    console.log(message);
} else if (command === 'readTodo') {
    var todo = todos.readTodo(argv.title);
    if (todo) {
        console.log('Great! The todo was found.');
        todos.logTodo(todo);
    } else {
        console.log('Whoops! The todo was not found.');
    }
} else {
    console.log('Invalid command.');
}

todos.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
console.log('Starting todos.js');
 
const fs = require('fs');
 
// add a todo item //
var addTodo = (title) => {
    var todos = fetchTodos();
    var todo = {
        title
    };
 
    var duplicatetodos = todos.filter((todo) => todo.title === title);
 
    if (duplicatetodos.length === 0) {
        todos.push(todo);
        saveTodos(todos);
        return todo;
    }
};
 
// delete a todo item //
var deleteTodo = (title) => {
    var todos = fetchTodos();
    var filteredtodos = todos.filter((todo) => todo.title !== title);
    saveTodos(filteredtodos);
 
    return todos.length !== filteredtodos.length;
};
 
//read a todo item //
var readTodo = (title) => {
    var todos = fetchTodos();
    var filteredTodos = todos.filter((todo) => todo.title === title);
    return filteredTodos[0];
};
 
// utility functions
var fetchTodos = () => {
    try {
        var todosString = fs.readFileSync('todos-data.json');
        return JSON.parse(todosString);
    } catch (e) {
        return [];
    }
};
 
var saveTodos = (todos) => {
    fs.writeFileSync('todos-data.json', JSON.stringify(todos));
};
 
var logTodo = (todo) => {
    console.log('------');
    console.log(`It's title is: ${todo.title}`);
};
 
// exported functions
module.exports = {
    addTodo,
    deleteTodo,
    readTodo,
    logTodo
};

¡Probémoslo! ¡Parece que está funcionando!

c: \ node> node app.js readTodo --title = "Cortar el césped"
Ejecutando app.js
Iniciando todos.js
Comando en ejecución: readTodo
¡Excelente! Se encontró el todo.
------
Su título es: Corta el césped

c: \ node> node app.js readTodo --title = "Netflix y relajarse"
Ejecutando app.js
Iniciando todos.js
Comando en ejecución: readTodo
¡Ups! No se encontró la tarea.

Listado de todos los elementos de Todo

Por último, queremos tener la capacidad de enumerar todos los elementos de la aplicación. Eche un vistazo a la versión final de todos.js y app.js que agregan soporte para esto.
todos.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
console.log('Starting todos.js');
 
const fs = require('fs');
 
// add a todo item //
var addTodo = (title) => {
    var todos = fetchTodos();
    var todo = {
        title
    };
 
    var duplicatetodos = todos.filter((todo) => todo.title === title);
 
    if (duplicatetodos.length === 0) {
        todos.push(todo);
        saveTodos(todos);
        return todo;
    }
};
 
// delete a todo item //
var deleteTodo = (title) => {
    var todos = fetchTodos();
    var filteredtodos = todos.filter((todo) => todo.title !== title);
    saveTodos(filteredtodos);
 
    return todos.length !== filteredtodos.length;
};
 
// read a todo item //
var readTodo = (title) => {
    var todos = fetchTodos();
    var filteredTodos = todos.filter((todo) => todo.title === title);
    return filteredTodos[0];
};
 
// list all todo items //
var listTodos = () => {
    return fetchTodos();
};
 
// utility functions
var fetchTodos = () => {
    try {
        var todosString = fs.readFileSync('todos-data.json');
        return JSON.parse(todosString);
    } catch (e) {
        return [];
    }
};
 
var saveTodos = (todos) => {
    fs.writeFileSync('todos-data.json', JSON.stringify(todos));
};
 
var logTodo = (todo) => {
    console.log('------');
    console.log(`It's title is: ${todo.title}`);
};
 
// exported functions
module.exports = {
    addTodo,
    deleteTodo,
    readTodo,
    listTodos,
    logTodo
};

app.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
console.log('Running app.js');
 
const fs = require('fs');
const _ = require('lodash');
const yargs = require('yargs');
 
const todos = require('./todos.js');
 
const argv = yargs.argv;
var command = argv._[0];
 
console.log('Running Command: ', command);
 
if (command === 'addTodo') {
    todos.addTodo(argv.title);
} else if (command === 'deleteTodo') {
    var todoDeleted = todos.deleteTodo(argv.title);
    var message = todoDeleted ? 'Todo was deleted' : 'Todo not found';
    console.log(message);
} else if (command === 'readTodo') {
    var todo = todos.readTodo(argv.title);
    if (todo) {
        console.log('Great! The todo was found.');
        todos.logTodo(todo);
    } else {
        console.log('Whoops! The todo was not found.');
    }
} else if (command === 'listTodos') {
    var allTodos = todos.listTodos();
    console.log(`Printing ${allTodos.length} todo(s).`);
    allTodos.forEach((todo) => todos.logTodo(todo));
} else {
    console.log('Invalid command.');
}

Una vez más podemos ejecutar la aplicación y probar este nuevo comando. ¡Luciendo bien!

c: \ nodo> nodo app.js listTodos
Ejecutando app.js
Iniciando todos.js
Comando en ejecución: listTodos
Impresión de 3 todo (s).
------
Su título es: Corta el césped
------
Su título es: Ve a trabajar
------
Su título es: Leer el periódico