Forgot Your Password?

Choose Your Plan

Start Building Real Apps

Pay Monthly

12

Pay Yearly

10
2 months free
Top shelf web developer training.

Guided Paths

Follow our crafted routes to reach your goals.

Courses

Premium content to build real apps.

Code Tutorials

Examples to follow and learn from.

Node.js modules syntax ES6

Introduccion

Desde su llegada de las clases a Node.js la app tiene que empezar a contruirse en POO ES6 asi que tarde o temprano llega la hora de dividir el codigo para tenerlo mejor estructurado. en los siguiente ejemplos veremos algunas mejores practicas:

  • Funciones
  • Constantes
  • Clases o Multiple clases
  • Importar modulos index file
  • Importar modulos as default
  • JSON [in-progress]
    • as ?? [in-progress]

Export

Funciones

no utilizar Si, solo si. cuando el archivo es un config file. Como dijimos node.js desde el momento que soporto clases todo tiene que estar orientado a objetos.

// module "aritmetica.js"
export function sumar(x, y) {
  return x + y;
}
export function restar(x, y) {
  return x - y;
}

// module "main.js"
import {sumar, restar} from './aritmetica';
sumar(2, 2); // 4
restar(2, 2); // 0

Constantes

// module "number.js"
export const ONE = 1;
export const TWO = 2;
export const THREE = 3;

// module "main.js"
import {ONE, TWO, THREE} from './number';
console.log(ONE); // 1
console.log(TWO); // 2
console.log(THREE); // 3

Clases o Multiple clases

Simple clases

Recomendable es que cada archivos del projecto sea la representacion de una clase.

// module "article.js"
export class Article {}

// module "main.js"
import { Article } from './publicacion';
let article = new Article();
article instanceof Article; // true

Multiple clases

Usar, si solo si, cuando las dos clases funcionen juntas ejemplo:

  • Listas enlazadas (clases LinkedList, Node) para que una clases enlazada funcion es imprescindible tener la clase nodo por ello es necesario que al importar se le haga de la misma manera.
// module "linked-list.js"
export class LinkedList {}
export class Node {}

// module "main.js"
import { LinkedList, Node } from './linked-list';
let linkedList = new LinkedList();
let node = new Node();
linkedList instanceof LinkedList; // true
node instanceof Node; // true

Importar modules Index file

usualmente cada folder creado en NODE suele representar un modulo. como vemos en el ejemplo:

// module "publicaciones/article.js"
export class Article {}
// module "publicaciones/post.js"
export class Post {}

como vemos en el ejemplo el folder publicaciones tiene dos clases.. ┬┐Pero que pasaria si tiene el mismo nombre? como el siguiente ejemplo:

// module "local-store/local-store.js"
export class LocalStore {}

// module "main.js"
import { LocalStore } from './local-store/local-store';

hay un error aqui!! al importar escribimos dos veces la sentecia local-store ahi.. es donde entra nuestro file index.

  • Cuando hacemos un import node automaticamente revisa si el folder contiene un archivo index.js
  • el ejemplo anterios funcionaria de manera correcta de la siguiente forma
// module "local-store/local-store.js"
export class LocalStore {}
// module "local-store/index.js"
import LocalStore from './local-store';
export LocalStore;

// module "main.js"
import { LocalStore } from './local-store';

como se puede observar en este ultimo ejemplo hacemos una envoltura de la clases LocalStore dentro del archivo index

Importar modulos as default

no utilizar

Otra estrategia que bastante se utiliza para importar modulos es la siguiente:

// module "local-store/local-store.js"
export default class LocalStore {} // se agrega default a la expresion export

// module "main.js"
import LocalStore from './local-store'; // no es necesario que al importar utilizemos las llaves para acceder a la clase
let localStore = new LocalStore(); // Ej. 1
localStore instanceof LocalStore; // ??

// module "main.js"
import Store from './local-store';
let store = new Store(); // Ej. 2
store instanceof Store; // ??

Esta forma de importar es muy usada.. por su simplesa a la hora de implementar. pero el motivo principal para no utilizarlo parte a la hora de compara los ejemplos 1 y 2.

  • La implementacion deja la posibilidad de que el programador pueda cambiar el nombre de la clase un cualquier otro lugar que maneje la referencia.

  • Habilita a error de validaciones de parametros.

Otras Publicaciones