clean-code-javascript

Contenido

Introducción

Variables

Utiliza nombres con sentido y de fácil pronunciación para las variables

constyyyymmdstr=moment().format("YYYY/MM/DD");

constfechaActual=moment().format("YYYY/MM/DD");

Utiliza el mismo tipo de vocabulario para el mismo tipo de variables

conseguirInformacionUsuario();conseguirDatosCliente();conseguirRegistroCliente();

conseguirUsuario();

Utiliza nombres que puedan ser buscados

// Para que cojones sirve 86400000?setTimeout(blastOff,86400000);

// Declaralas como constantes nombradasconstMILISEGUNDOS_POR_DIA=86400000;setTimeout(blastOff,MILISEGUNDOS_POR_DIA);

Utiliza variables explicativas

constdireccion="Calle Mallorca, Barcelona 95014";constexpresionRegularCodigoPostalCiudad=/^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$/;guardarCP(direccion.match(expresionRegularCodigoPostalCiudad)[1],direccion.match(expresionRegularCodigoPostalCiudad)[2]);

constdireccion="One Infinite Loop, Cupertino 95014";constexpresionRegularCodigoPostalCiudad=/^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$/;const[,ciudad,codigoPostal]=direccion.match(expresionRegularCodigoPostalCiudad)||[];guardarCP(ciudad,codigoPostal);

Evita relaciones mentales

constciudades=["Barcelona","Madrid","Sitges"];ciudades.forEach(l=>{hacerAlgo();hacerAlgoMas();// ...// ...// ...// Espera, para que era `l`?dispatch(l);});

constciudades=["Barcelona","Madrid","Sitges"];ciudades.forEach(direccion=>{hacerAlgo();hacerAlgoMas();// ...// ...// ...dispatch(direccion);});

No añadas contexto innecesario

constCoche={marcaCoche:"Honda",modeloCoche:"Accord",colorCoche:"Azul"};functionpintarCoche(coche){coche.colorCoche="Rojo";}

constCoche={marca:"Honda",modelo:"Accord",color:"Azul"};functionpintarCoche(coche){coche.color="Rojo";}

Utiliza argumentos por defecto en vez de circuitos cortos o condicionales

functioncrearMicroCerveceria(nombre){constnombreMicroCerveceria=nombre||"Hipster Brew Co.";// ...}

functioncrearMicroCerveceria(nombre="Hipster Brew Co."){// ...}

Funciones

Argumentos de una función (idealmente 2 o menos)

functioncrearMenu(titulo,cuerpo,textoDelBoton,cancelable){// ...}

functioncrearMenu({ titulo, cuerpo, textoDelBoton, cancelable}){// ...}crearMenu({titulo:"Foo",cuerpo:"Bar",textoDelBoton:"Baz",cancelable:true});

Las funciones deberían hacer una cosa

functionenviarCorreoAClientes(clientes){clientes.forEach(cliente=>{consthistoricoDelCliente=baseDatos.buscar(cliente);if(historicoDelCliente.estaActivo()){enviarEmail(cliente);}});}

functionenviarCorreoClientesActivos(clientes){clientes.filter(esClienteActive).forEach(enviarEmail);}functionesClienteActivo(cliente){consthistoricoDelCliente=baseDatos.buscar(cliente);returnhistoricoDelCliente.estaActivo();}

Los nombres de las funciones deberían decir lo que hacen

functionañadirAFecha(fecha,mes){// ...}constfecha=newDate();// Es difícil saber que se le está añadiendo a la fecha en este casoañadirAFecha(fecha,1);

functionañadirMesAFecha(mes,fecha){// ...}constfecha=newDate();añadirMesAFecha(1,fecha);

Las funciones deberían ser únicamente de un nivel de abstracción

functionanalizarMejorAlternativaJavascript(codigo){constEXPRESIONES_REGULARES=[// ...];constdeclaraciones=codigo.split(" ");consttokens=[];EXPRESIONES_REGULARES.forEach(EXPRESION_REGULAR=>{declaraciones.forEach(declaracion=>{// ...});});constast=[];tokens.forEach(token=>{// lex...});ast.forEach(nodo=>{// parse...});}

functionanalizarMejorAlternativaJavascript(codigo){consttokens=tokenize(codigo);constast=lexer(tokens);ast.forEach(nodo=>{// parse...});}functiontokenize(codigo){constEXPRESIONES_REGULARES=[// ...];constdeclaraciones=codigo.split(" ");consttokens=[];EXPRESIONES_REGULARES.forEach(EXPRESION_REGULAR=>{declaraciones.forEach(declaracion=>{tokens.push(/* ... */);});});returntokens;}functionlexer(tokens){constast=[];tokens.forEach(token=>{ast.push(/* ... */);});returnast;}

Elimina código duplicado

functionmostrarListaDesarrolladores(desarrolladores){desarrolladores.forEach(desarrollador=>{constsalarioEsperado=desarrollador.calcularSalarioEsperado();constexperiencia=desarrollador.conseguirExperiencia();constenlaceGithub=desarrollador.conseguirEnlaceGithub();constdatos={      salarioEsperado,      experiencia,      enlaceGithub};render(datos);});}functionmostrarListaJefes(jefes){jefes.forEach(jefe=>{constsalarioEsperado=desarrollador.calcularSalarioEsperado();constexperiencia=desarrollador.conseguirExperiencia();constexperienciaLaboral=jefe.conseguirProyectosMBA();constdata={      salarioEsperado,      experiencia,      experienciaLaboral};render(data);});}

functionmostrarListaEmpleados(empleados){empleados.forEach(empleado=>{constsalarioEsperado=empleado.calcularSalarioEsperado();constexperiencia=empleado.conseguirExperiencia();constdatos={      salarioEsperado,      experiencia};switch(empleado.tipo){case"jefe":datos.portafolio=empleado.conseguirProyectosMBA();break;case"desarrollador":datos.enlaceGithub=empleado.conseguirEnlaceGithub();break;}render(datos);});}

Asigna objetos por defecto con Object.assign

constconfiguracionMenu={titulo:null,contenido:"Bar",textoBoton:null,cancelable:true};functioncrearMenu(config){config.titulo=config.titulo||"Foo";config.contenido=config.contenido||"Bar";config.textoBoton=config.textoBoton||"Baz";config.cancelable=config.cancelable!==undefined ?config.cancelable :true;}crearMenu(configuracionMenu);

constconfiguracionMenu={titulo:"Order",// El usuario no incluyó la clave 'contenido'textoBoton:"Send",cancelable:true};functioncrearMenu(configuracion){configuracion=Object.assign({titulo:"Foo",contenido:"Bar",textoBoton:"Baz",cancelable:true},configuracion);// configuracion ahora es igual a: {titulo: "Order", contenido: "Bar", textoBoton: "Send", cancelable: true}// ...}crearMenu(configuracionMenu);

No utilices banderas o flags

functioncrearFichero(nombre,temporal){if(temporal){fs.create(`./temporal/${nombre}`);}else{fs.create(nombre);}}

functioncrearFichero(nombre){fs.create(nombre);}functioncrearFicheroTemporal(nombre){crearFichero(`./temporal/${nombre}`);}

Evita los efectos secundarios (parte 1)

// Variable Global referenciada por la siguiente función// Si tuvieramos otra función que usara ese nombre, podría ser un array y lo estaríamos rompiendo// If we had another function that used this name, now it'd be an array and it could break it.letnombre='Ryan McDermott';functionsepararEnNombreYApellido(){nombre=nombre.split(' ');}separarEnNombreYApellido();console.log(nombre);// ['Ryan', 'McDermott'];

functionsepararEnNombreYApellido(nombre){returnnombre.split(' ');}constnombre='Ryan McDermott';constnuevoNombre=separarEnNombreYApellido(nombre);console.log(nombre);// 'Ryan McDermott';console.log(nuevoNombre);// ['Ryan', 'McDermott'];

Evita los efectos secundarios (parte 2)

constañadirObjetoAlCarrito=(carrito,objeto)=>{carrito.push({ objeto,fecha:Date.now()});};

constañadirObjetoAlCarrito=(carrito,objeto)=>{return[...carrito,{ objeto,fecha:Date.now()}];};

No escribas en variables globales

Array.prototype.diff=functiondiff(matrizDeComparación){consthash=newSet(matrizDeComparación);returnthis.filter(elemento=>!hash.has(elemento));};

classSuperArrayextendsArray{diff(matrizDeComparación){consthash=newSet(matrizDeComparación);returnthis.filter(elemento=>!hash.has(elemento));}}

Da prioridad a la programación funcional en vez de la programación imperativa

constdatosSalidaProgramadores=[{nombre:"Uncle Bobby",liniasDeCodigo:500},{nombre:"Suzie Q",liniasDeCodigo:1500},{nombre:"Jimmy Gosling",liniasDeCodigo:150},{nombre:"Gracie Hopper",liniasDeCodigo:1000}];letsalidaFinal=0;for(leti=0;i<datosSalidaProgramadores.length;i++){salidaFinal+=datosSalidaProgramadores[i].liniasDeCodigo;}

constdatosSalidaProgramadores=[{nombre:"Uncle Bobby",liniasDeCodigo:500},{nombre:"Suzie Q",liniasDeCodigo:1500},{nombre:"Jimmy Gosling",liniasDeCodigo:150},{nombre:"Gracie Hopper",liniasDeCodigo:1000}];constsalidaFinal=datosSalidaProgramadores.map(salida=>salida.linesOfCode).reduce((totalLinias,linias)=>totalLinias+linias);

Encapsula los condicionales

if(fsm.state==="cogiendoDatos"&&estaVacio(listaNodos)){// ...}

functiondeberiaMostrarSpinner(fsm,listaNodos){returnfsm.state==="cogiendoDatos"&&estaVacio(listaNodos);}if(deberiaMostrarSpinner(fsmInstance,listNodeInstance)){// ...}

Evita condicionales negativos

functionnoEstaElNodoPresente(node){// ...}if(!noEstaElNodoPresente(node)){// ...}

functionestaElNodoPresente(node){// ...}if(estaElNodoPresente(node)){// ...}

Evita condicionales

classAvion{// ...obtenerAlturaDeVuelo(){switch(this.tipo){case"777":returnthis.cogerAlturaMaxima()-this.conseguirNumeroPasajeros();case"Air Force One":returnthis.cogerAlturaMaxima();case"Cessna":returnthis.cogerAlturaMaxima()-this.getFuelExpenditure();}}}

classAvion{// ...}classBoeing777extendsAvion{// ...obtenerAlturaDeVuelo(){returnthis.cogerAlturaMaxima()-this.conseguirNumeroPasajeros();}}classAirForceOneextendsAvion{// ...obtenerAlturaDeVuelo(){returnthis.cogerAlturaMaxima();}}classCessnaextendsAvion{// ...obtenerAlturaDeVuelo(){returnthis.cogerAlturaMaxima()-this.getFuelExpenditure();}}

Evita el control de tipos (parte 1)

functionviajarATexas(vehiculo){if(vehiculoinstanceofBicicleta){vehiculo.pedalear(this.ubicacionActual,newLocalizacion("texas"));}elseif(vehiculoinstanceofCar){vehiculo.conducir(this.ubicacionActual,newLocalizacion("texas"));}}

functionviajarATexas(vehiculo){vehiculo.mover(this.ubicacionActual,newLocalizacion("texas"));}

Evita control de tipos (parte 2)

functioncombina(valor1,valor2){if((typeofvalor1==="number"&&typeofvalor2==="number")||(typeofvalor1==="string"&&typeofvalor2==="string")){returnvalor1+valor2;}thrownewError("Debería ser una cadena o número");}

functioncombina(valor1,valor2){returnvalor1+valor2;}

No optimizes al máximo

// En los navegadores antiguos, cada iteración en la que `list.length` no esté cacheada// podría ser costosa por el recálculo de este valor. En los modernos, ya está optimizadofor(leti=0,tamaño=lista.length;i<tamaño;i++){// ...}

for(leti=0;i<lista.length;i++){// ...}

Borra código inútil

functionantiguoModuloDePeticiones(url){// ...}functionnuevoModuloDePeticiones(url){// ...}constpeticion=nuevoModuloDePeticiones;calculadorDeInventario("manzanas",peticion,"www.inventory-awesome.io");

functionnuevoModuloDePeticiones(url){// ...}constpeticion=nuevoModuloDePeticiones;calculadorDeInventario("manzanas",peticion,"www.inventory-awesome.io");

Objectos y estructuras de datos

Utiliza setters y getters

functioncrearCuentaBancaria(){// ...return{balance:0// ...};}constcuenta=crearCuentaBancaria();cuenta.balance=100;

functioncrearCuentaBancaria(){// Esta es privadaletbalance=0;// Un "getter", hecho público a través del objeto que retornamos abajofunctioncogerBalance(){returnbalance;}// Un "setter", hecho público a través del objeto que retornamos abajofunctionintroducirBalance(cantidad){// ... validamos antes de hcaer un balancebalance=cantidad;}return{// ...    cogerBalance,    introducirBalance};}constcuenta=crearCuentaBancaria();cuenta.introducirBalance(100);

Hacer que los objetos tengan atributos/métodos privados

constEmpleado=function(nombre){this.nombre=nombre;};Empleado.prototype.cogerNombre=functioncogerNombre(){returnthis.nombre;};constempleado=newEmpleado("John Doe");console.log(`Nombre del empleado:${empleado.cogerNombre()}`);// Nombre del empleado: John Doedeleteempleado.nombre;console.log(`Nombre del empleado:${empleado.cogerNombre()}`);// Nombre del empleado: undefined

functioncrearEmpleado(name){return{cogerNombre(){returnname;}};}constempleado=crearEmpleado("John Doe");console.log(`Nombre del empleado:${empleado.cogerNombre()}`);// Nombre del empleado: John Doedeleteempleado.name;console.log(`Nombre del empleado:${empleado.cogerNombre()}`);// Nombre del empleado: John Doe

Clases

Prioriza las classes de ES2015/ES6 antes que las funciones planas de ES50

constAnimal=function(edad){if(!(thisinstanceofAnimal)){thrownewError("Inicializa Animal con `new`");}this.edad=edad;};Animal.prototype.mover=functionmover(){};constMamifero=function(edad,furColor){if(!(thisinstanceofMamifero)){thrownewError("Inicializa Mamifero con `new`");}Animal.call(this,edad);this.furColor=furColor;};Mamifero.prototype=Object.create(Animal.prototype);Mamifero.prototype.constructor=Mamifero;Mamifero.prototype.aniversario=functionaniversario(){};constHumano=function(edad,furColor,idioma){if(!(thisinstanceofHumano)){thrownewError("Inicializa Humano con `new`");}Mamifero.call(this,edad,furColor);this.idioma=idioma;};Humano.prototype=Object.create(Mamifero.prototype);Humano.prototype.constructor=Humano;Humano.prototype.hablar=functionhablar(){};

classAnimal{constructor(edad){this.edad=edad;}mover(){/* ... */}}classMamiferoextendsAnimal{constructor(edad,furColor){super(edad);this.furColor=furColor;}aniversario(){/* ... */}}classHumanextendsMamifero{constructor(edad,furColor,idioma){super(edad,furColor);this.idioma=idioma;}hablar(){/* ... */}}

Utiliza el anidación de funciones

classCoche{constructor(marca,modelo,color){this.marca=marca;this.modelo=modelo;this.color=color;}introducirMarca(marca){this.marca=marca;}introducirModelo(modelo){this.modelo=modelo;}introducirColor(color){this.color=color;}guardar(){console.log(this.marca,this.modelo,this.color);}}constcoche=newCoche("Ford","F-150","rojo");coche.introducirColor("rosa");coche.guardar();

classCoche{constructor(marca,modelo,color){this.marca=marca;this.modelo=modelo;this.color=color;}introducirMarca(marca){this.marca=marca;// NOTE: Retornamos this para poder anidas funcionesreturnthis;}introducirModelo(modelo){this.modelo=modelo;// NOTE: Retornamos this para poder anidas funcionesreturnthis;}introducirColor(color){this.color=color;// NOTE: Retornamos this para poder anidas funcionesreturnthis;}guardar(){console.log(this.marca,this.modelo,this.color);// NOTE: Retornamos this para poder anidas funcionesreturnthis;}}constcoche=newCoche("Ford","F-150","rojo").introducirColor("rosa").guardar();

Prioriza la composición en vez de la herecia

classEmpleado{constructor(nombre,correoElectronico){this.nombre=nombre;this.correoElectronico=correoElectronico;}// ...}// Bad because Employees "have" tax data. EmployeeTaxData is not a type of EmpleadoclassInformacionImpuestosEmpleadoextendsEmpleado{constructor(ssn,salario){super();this.ssn=ssn;this.salario=salario;}// ...}

classInformacionImpuestosEmpleado{constructor(ssn,salario){this.ssn=ssn;this.salario=salario;}// ...}classEmpleado{constructor(nombre,correoElectronico){this.nombre=nombre;this.correoElectronico=correoElectronico;}introducirInformacionImpuestos(ssn,salario){this.informacionImpuestos=newInformacionImpuestosEmpleado(ssn,salario);}// ...}

SOLID

Principio de Responsabilidad Única (SRP)

classOpcionesUsuario{constructor(usuario){this.usuario=usuario;}changeSettings(opciones){if(this.verificarCredenciales()){// ...}}verificarCredenciales(){// ...}}

classAutenticationUsuario{constructor(usuario){this.usuario=usuario;}verificarCredenciales(){// ...}}classUserSettings{constructor(usuario){this.usuario=usuario;this.autenticacion=newAutenticationUsuario(usuario);}changeSettings(settings){if(this.autenticacion.verificarCredenciales()){// ...}}}

Principio de abierto/cerrado (OCP)

classAdaptadorAjaxextendsAdaptador{constructor(){super();this.name="adaptadorAjax";}}classAdaptadorNodosextendsAdaptador{constructor(){super();this.nombre="adaptadorNodos";}}class{constructor(adapter){this.adapter=adapter;}fetch(url){if(this.adapter.nombre==="adaptadorAjax"){returnhacerLlamadaAjax(url).then(respuesta=>{// transformar la respuesta y devolverla});}elseif(this.adapter.nombre==="adaptadorHttpNodos"){returnhacerLlamadaHttp(url).then(respuesta=>{// transformar la respuesta y devolverla});}}}functionhacerLlamadaAjax(url){// request and return promise}functionhacerLlamadaHttp(url){// request and return promise}

classAdaptadorAjaxextendsAdapter{constructor(){super();this.nombre="adaptadorAjax";}pedir(url){// Pedir y devolver la promesa}}classAdaptadorNodosextendsAdapter{constructor(){super();this.nombre="adaptadorNodos";}pedir(url){// Pedir y devolver la promesa}}classEjecutadorPeticionesHttp{constructor(adaptador){this.adaptador=adaptador;}fetch(url){returnthis.adaptador.pedir(url).then(respuesta=>{// Transformar y devolver la respuesta});}}

Principio de sustitución de Liskov (LSP)

classRectangulo{constructor(){this.anchura=0;this.altura=0;}introducirColor(color){// ...}render(area){// ...}introducirAnchura(anchura){this.anchura=anchura;}introducirAltura(altura){this.altura=altura;}conseguirArea(){returnthis.anchura*this.altura;}}classCuadradoextendsRectangulo{introducirAnchura(anchura){this.anchura=anchura;this.altura=anchura;}introducirAltura(altura){this.width=altura;this.altura=altura;}}functionrenderizaRectangulosLargos(rectangulos){rectangulos.forEach(rectangulo=>{rectangulo.introducirAnchura(4);rectangulo.introducirAltura(5);constarea=rectangulo.conseguirArea();// MAL: Para el cuadrado devuelve 25 y devería ser 20rectangulo.render(area);});}constrectangulos=[newRectangulo(),newRectangulo(),newCuadrado()];renderizaRectangulosLargos(rectangulos);

classForma{introducirColor(color){// ...}render(area){// ...}}classRectanguloextendsForma{constructor(width,height){super();this.anchura=anchura;this.altura=altura;}conseguirArea(){returnthis.anchura*this.altura;}}classCuadradoextendsForma{constructor(distancia){super();this.distancia=distancia;}conseguirArea(){returnthis.distancia*this.distancia;}}functionrenderizaRectangulosLargos(shapes){shapes.forEach(shape=>{constarea=shape.conseguirArea();shape.render(area);});}constshapes=[newRectangulo(4,5),newRectangulo(4,5),newCuadrado(5)];renderizaRectangulosLargos(shapes);

Principio de Segregacion de Interfaces (ISP)

classDOMTraverser{constructor(configuraciones){this.configuraciones=configuraciones;this.setup();}preparar(){this.nodoRaiz=this.configuraciones.nodoRaiz;this.ModuloAnimacion.preparar();}atravesar(){// ...}}const$=newDOMTraverser({nodoRaiz:document.getElementsByTagName("body"),moduloAnimacion(){}// Most of the time, we won't need to animate when traversing.// ...});

classDOMTraverser{constructor(configuraciones){this.configuraciones=configuraciones;this.opciones=configuraciones.opciones;this.preparar();}preparar(){this.nodoRaiz=this.configuraciones.nodoRaiz;this.prepararOpciones();}prepararOpciones(){if(this.opciones.moduloAnimacion){// ...}}atravesar(){// ...}}const$=newDOMTraverser({nodoRaiz:document.getElementsByTagName("body"),opciones:{moduloAnimacion(){}}});

Principio de Inversión de Dependencias (DIP)

classSolicitadorDeInventario{constructor(){this.REQ_METHODS=["HTTP"];}pedirArticulo(articulo){// ...}}classRastreadorDeInventario{constructor(articulos){this.articulos=articulos;// MAL: Hemos creado una dependencia de una concreción que va atada a una implementación// Deberíamos tener pedirArticulos  dependiendo únicamente de un método: 'solicitud'this.solicitador=newSolicitadorDeInventario();}pedirArticulos(){this.articulos.forEach(articulo=>{this.solicitador.pedirArticulo(articulo);});}}constrastreadorDeInventario=newRastreadorDeInventario(["manzanas","platanos"]);rastreadorDeInventario.pedirArticulos();

classRastreadorDeInventario{constructor(articulos,solicitador){this.articulos=articulos;this.solicitador=solicitador;}pedirArticulos(){this.articulos.forEach(articulo=>{this.solicitador.pedirArticulo(articulo);});}}classSolicitadorDeInventarioV1{constructor(){this.REQ_METHODS=["HTTP"];}pedirArticulo(articulo){// ...}}classSolicitadorDeInventarioV2{constructor(){this.REQ_METHODS=["WS"];}pedirArticulo(articulo){// ...}}// By constructing our dependencies externally and injecting them, we can easily// substitute our request module for a fancy new one that uses WebSockets.// Construyendo nuestras dependencias desde fuera e inyectandolas, podríamos// substituir nuestro Módulo solicitador por uno con websockets o lo que seaconstrastreadorDeInventario=newRastreadorDeInventario(["manzanas","platanos"],newSolicitadorDeInventarioV2());rastreadorDeInventario.pedirArticulos();

Testing

Sólo un concepto por test

importassertfrom"assert";describe("MakeMomentJSGreatAgain",()=>{it("maneja límites de las fechas",()=>{letfecha;fecha=newMakeMomentJSGreatAgain("1/1/2015");fecha.addDays(30);assert.equal("1/31/2015",fecha);fecha=newMakeMomentJSGreatAgain("2/1/2016");fecha.addDays(28);assert.equal("02/29/2016",fecha);fecha=newMakeMomentJSGreatAgain("2/1/2015");fecha.addDays(28);assert.equal("03/01/2015",fecha);});});

importassertfrom"assert";describe("MakeMomentJSGreatAgain",()=>{it("Maneja los meses con 30 días",()=>{constfecha=newMakeMomentJSGreatAgain("1/1/2015");fecha.addDays(30);assert.equal("1/31/2015",fecha);});it("Maneja los años bisiestos",()=>{constfecha=newMakeMomentJSGreatAgain("2/1/2016");fecha.addDays(28);assert.equal("02/29/2016",fecha);});it("Maneja los años NO bisiestos",()=>{constfecha=newMakeMomentJSGreatAgain("2/1/2015");fecha.addDays(28);assert.equal("03/01/2015",fecha);});});

Concurrencia

Usa Promesas, no callbacks

import{get}from"request";import{writeFile}from"fs";get("https://en.wikipedia.org/wiki/Robert_Cecil_Martin",(requestErr,respuesta)=>{if(requestErr){console.error(requestErr);}else{writeFile("article.html",respuesta.body,writeErr=>{if(writeErr){console.error(writeErr);}else{console.log("File written");}});}});

import{get}from"request";import{writeFile}from"fs";get("https://en.wikipedia.org/wiki/Robert_Cecil_Martin").then(respuesta=>{returnwriteFile("article.html",respuesta);}).then(()=>{console.log("File written");}).catch(err=>{console.error(err);});

Async/Await is incluso más limpio que las Promesas

import{get}from"request-promise";import{writeFile}from"fs-promise";get("https://en.wikipedia.org/wiki/Robert_Cecil_Martin").then(respuesrta=>{returnwriteFile("article.html",respuesrta);}).then(()=>{console.log("File written");}).catch(err=>{console.error(err);});

import{get}from"request-promise";import{writeFile}from"fs-promise";asyncfunctionconseguirArticulosDeCodigoLimpio(){try{constrespuesrta=awaitget("https://en.wikipedia.org/wiki/Robert_Cecil_Martin");awaitwriteFile("article.html",respuesrta);console.log("File written");}catch(err){console.error(err);}}

Manejo de errores

No ignores los errores capturados

try{functionQueDeberiaLanzarError();}catch(error){console.log(error);}

try{functionQueDeberiaLanzarError();}catch(error){// Una option (algo más molesta que el convencional console.log)console.error(error);// Otra opción:notificarAlUsuarioDelError(error);// Otra opción:reportarElArrorAUnServicio(error);// O hazlas todas!}

No ignores las promesas rechazadas

cogerDatos().then(datos=>{functionQueDeberiaLanzarError(datos);}).catch(error=>{console.log(error);});

cogerDatos().then(datos=>{functionQueDeberiaLanzarError(datos);}).catch(error=>{// Una option (algo más molesta que el convencional console.log)console.error(error);// Otra opción:notificarAlUsuarioDelError(error);// Otra opción:reportarElArrorAUnServicio(error);// O hazlas todas!});

Formato

Usa consistenemente la capitalización

constDIAS_POR_SEMANA=7;constdiasPorMes=30;constcanciones=["Back In Black","Stairway to Heaven","Hey Jude"];constArtistas=["ACDC","Led Zeppelin","The Beatles"];functionborrarBaseDeDatos(){}functionrestablecer_baseDeDatos(){}classanimal{}classAlpaca{}

constDIAS_POR_SEMANA=7;constDIAS_POR_MES=30;constCANCIONES=["Back In Black","Stairway to Heaven","Hey Jude"];constARTISTAS=["ACDC","Led Zeppelin","The Beatles"];functionborrarBaseDeDatos(){}functionrestablecerBaseDeDatos(){}classAnimal{}classAlpaca{}

Funciones que llaman y funciones que son llamadas, deberían estar cerca

classRevisionDeRendimiento{constructor(empleado){this.empleado=empleado;}conseguirCompañeros(){returndb.buscar(this.empleado,"compañeros");}conseguirJefe(){returndb.buscar(this.empleado,"jefe");}conseguirOpinionDeLosCompañeros(){constcompañeros=this.conseguirCompañeros();// ...}executarRevision(){this.conseguirOpinionDeLosCompañeros();this.conseguirOpinionDelJefe();this.conseguirAutoRevision();}conseguirOpinionDelJefe(){constjefe=this.conseguirJefe();}conseguirAutoRevision(){// ...}}constreview=newRevisionDeRendimiento(empleado);review.executarRevision();

classRevisionDeRendimiento{constructor(empleado){this.empleado=empleado;}executarRevision(){this.conseguirOpinionDeLosCompañeros();this.conseguirOpinionDelJefe();this.conseguirAutoRevision();}conseguirOpinionDeLosCompañeros(){constcompañeros=this.conseguirCompañeros();// ...}conseguirCompañeros(){returndb.buscar(this.empleado,"compañeros");}conseguirOpinionDelJefe(){constjefe=this.conseguirJefe();}conseguirJefe(){returndb.buscar(this.empleado,"jefe");}conseguirAutoRevision(){// ...}}constreview=newRevisionDeRendimiento(empleado);review.executarRevision();

Comentarios

Comenta únicamente la lógica de negocio que es compleja

functionhashIt(datos){// El hashlethash=0;// Tamaño del stringconsttamaño=datos.length;// Iteramos a través de cada carácter de los datosfor(leti=0;i<tamaño;i++){// Coger código del caracterconstchar=datos.charCodeAt(i);// Crear el hashhash=(hash<<5)-hash+char;// Convertir a un entero de 32 bitshash&=hash;}}

functionhashIt(datos){lethash=0;consttamaño=datos.length;for(leti=0;i<tamaño;i++){constcaracter=datos.charCodeAt(i);hash=(hash<<5)-hash+caracter;// Convertir a un entero de 32 bitshash&=hash;}}

No dejes código comentado en tu repositorio

hacerCosas();// hacerOtrasCosas();// hacerCosasAunMasRaras();// estoHaceMaravillas();

hacerCosas();

No hagas un diario de comentarios

/** * 2016-12-20: `monads` borrados, no hay quien los entienda * 2016-10-01: Código mejorado con 'monads' * 2016-02-03: Borrado tipado * 2015-03-14: Añadido tipado */functioncombinar(a,b){returna+b;}

functioncombinar(a,b){returna+b;}

Evita los marcadores de secciones

////////////////////////////////////////////////////////////////////////////////// Instanciación del Modelo Scope////////////////////////////////////////////////////////////////////////////////$scope.modelo={menu:"foo",nav:"bar"};////////////////////////////////////////////////////////////////////////////////// Preparación de la acción////////////////////////////////////////////////////////////////////////////////constacciones=function(){// ...};

$scope.modelo={menu:"foo",nav:"bar"};constacciones=function(){// ...};

Traducciones