Table Des Matières

Introduction

Variables

Utilisez des noms de variables significatifs et prononçables

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

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

Utilisez le même vocabulaire pour le même type de variable

obtenirInformationDeUtilisateur();obtenirDonéesDuClient();obtenirFicheDuClient();

obtenirUtiilisateur();

Utilisez des noms interrogeables

// Qu'est-ce que c'est que 86400000?setTimeout(misÀFeu,86400000);

// Déclarez-les comme des constantes nommées capitalisées.constMILLISECONDES_PAR_JOUR=86400000;setTimeout(misÀFeu,MILLISECONDES_PAR_JOUR);

Utiliser des variables explicatives

constadresse="One Infinite Loop, Cupertino 95014";constcodePostalVilleRegex=/^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$/;enregistrerCodePostalVille(adresse.match(codePostalVilleRegex)[1],adresse.match(codePostalVilleRegex)[2]);

constadresse="One Infinite Loop, Cupertino 95014";constcodePostalVilleRegex=/^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$/;const[,ville,codePostal]=adresse.match(codePostalVilleRegex)||[];enregistrerCodePostalVille(ville,codePostal);

Éviter la cartographie mentale

constendroits=["Austin","New York","San Francisco"];endroits.forEach(l=>{faireDesTrucs();faireAutreChoses();// ...// ...// ...// Attendez, à quoi sert "l`"?dispatch(l);});

constendroits=["Austin","New York","San Francisco"];endroits.forEach(endroit=>{faireDesTrucs();faireAutreChoses();// ...// ...// ...dispatch(endroit);});

Ne pas ajouter de contexte inutile

constVoiture={marqueDeVoiture:"Honda",modèleDeVoiture:"Accord",couleurDeVoiture:"Bleue"};functionpeindreLaVoiture(voiture){voiture.couleurDeVoiture="Rouge";}

constVoiture={marque:"Honda",modèle:"Accord",couleur:"Bleue"};functionpeindreLaVoiture(voiture){voiture.couleur="Rouge";}

Utiliser des arguments par défaut au lieu de court-circuiter ou conditionnels

functioncréerUneMicroBrasserie(nom){constnomDeBrasserie=nom||"Hipster Brew Co.";// ...}

functioncréerUneMicroBrasserie(nom="Hipster Brew Co."){// ...}

Fonctions

Arguments de fonction (idéalement 2 ou moins)

functioncréerUnMenu(titre,corps,boutonTexte,annulable){// ...}

functioncréerUnMenu({ titre, corps, boutonTexte, annulable}){// ...}créerUnMenu({titre:"Foo",corps:"Bar",boutonTexte:"Baz",annulable:true});

Les fonctions doivent faire une chose

functionemailClients(clients){clients.forEach(client=>{constenregistrementDuClient=database.lookup(client);if(enregistrementDuClient.estActif()){email(client);}});}

functionemailClientsActifs(clients){clients.filter(estClientActif).forEach(email);}functionestClientActif(client){constenregistrementDuClient=database.lookup(client);returnenregistrementDuClient.estActif();}

Les noms de fonction doivent dire ce qu'ils font

functionajouterÀLaDate(date,mois){// ...}constdate=newDate();// Il est difficile de dire à partir du nom de la fonction ce qui est ajoutéajouterÀLaDate(date,1);

functionajouterMoisÀDate(mois,date){// ...}constdate=newDate();ajouterMoisÀDate(1,date);

Les fonctions ne devraient être qu'un seul niveau d'abstraction

functionmieuxAnalyserAlternatifJS(code){constREGEXES=[// ...];constdéclarations=code.split(" ");constjetons=[];REGEXES.forEach(REGEX=>{déclarations.forEach(déclaration=>{// ...});});constast=[];jetons.forEach(jeton=>{// lex...});ast.forEach(node=>{// parse...});}

functionmieuxAnalyserAlternatifJS(code){constjetons=tokenize(code);constarbreDeSyntaxe=analyser(jetons);arbreDeSyntaxe.forEach(node=>{// parse...});}functiontokenize(code){constREGEXES=[// ...];constdéclarations=code.split(" ");constjetons=[];REGEXES.forEach(REGEX=>{déclarations.forEach(déclaration=>{jetons.push(/* ... */);});});returnjetons;}functionanalyser(jetons){constarbreDeSyntaxe=[];jetons.forEach(jeton=>{arbreDeSyntaxe.push(/* ... */);});returnarbreDeSyntaxe;}

Supprimez le code en double

functionafficherLaListeDesDéveloppeurs(développeurs){développeurs.forEach(développeur=>{constsalairePrévu=développeur.calculerSalairePrévu();constexpérience=développeur.obtenirExpérience();constlienGithub=développeur.obtenirLienGithub();constdonnées={      salairePrévu,      expérience,      lienGithub};rendre(données);});}functionafficherLaListeDesGestionnaires(gestionnaires){gestionnaires.forEach(gestionnaire=>{constsalairePrévu=gestionnaire.calculerSalairePrévu();constexpérience=gestionnaire.obtenirExpérience();constportfolio=gestionnaire.obtenireProjetsMBA();constdonnées={      salairePrévu,      expérience,      portfolio};rendre(données);});}

functionafficherLaListeDesEmployés(employés){employés.forEach(employé=>{constsalairePrévu=employés.calculerSalairePrévu();constexpérience=employés.obtenirExpérience();constdonnées={      salairePrévu,      expérience};switch(employés.type){case"gestionnaire":data.portfolio=employés.obtenireProjetsMBA();break;case"développeur":data.lienGithub=employés.obtenirLienGithub();break;}rendre(données);});}

Définir des objets par défaut avec Object.assign

constconfigMenu={titre:null,corps:"Bar",boutonTexte:null,annulable:true};functioncréerUnMenu(config){config.titre=config.titre||"Foo";config.corps=config.corps||"Bar";config.boutonTexte=config.boutonTexte||"Baz";config.annulable=config.annulable!==undefined ?config.annulable :true;}créerUnMenu(configMenu);

constconfigMenu={titre:"Commande",// L'utilisateur n'a pas inclus la clé 'corps'boutonTexte:"Envoyer",annulable:true};functioncréerUnMenu(config){config=Object.assign({titre:"Foo",corps:"Bar",boutonTexte:"Baz",annulable:true},config);// config est maintenant égal à: {titre: "Commande", corps: "Bar", boutonTexte - "Envoyer", annulable: true}// ...}créerUnMenu(configMenu);

Ne pas utiliser les drapeaux comme paramètres de fonction

functioncréerUnFichier(nom,temp){if(temp){fs.create(`./temp/${nom}`);}else{fs.create(nom);}}

functioncréerUnFichier(nom){fs.create(nom);}functioncréerUnFichierTemp(nom){créerUnFichier(`./temp/${nom}`);}

Éviter les effets secondaires (partie 1)

// Variable globale référencée par la fonction suivante.// Si nous avions une autre fonction qui utilisait ce nom, maintenant ce serait un tableau et cela pourrait le casser.letnom="Gavish Barosee";functiondiviséEnPrénomEtNom(){nom=nom.split(" ");}diviséEnPrénomEtNom();console.log(nom);// ['Gavish', 'Barosee'];

functiondiviséEnPrénomEtNom(nom){returnnom.split(" ");}constnom="Gavish Barosee";constnouveauNom=splitIntoFirstAndLastName(nom);console.log(nom);// 'Gavish Barosee';console.log(nouveauNom);// ['Gavish', 'Barosee'];

Éviter les effets secondaires (partie 2)

constAjouterUnArticleAuPanier=(panier,article)=>{cart.push({ article,date:Date.now()});};

constAjouterUnArticleAuPanier=(panier,article)=>{return[...panier,{ article,date:Date.now()}];};

Ne pas écrire dans les fonctions globales

Array.prototype.diff=functiondiff(tableauDeComparaison){consthash=newSet(tableauDeComparaison);returnthis.filter(elem=>!hash.has(elem));};

classSuperArrayextendsArray{diff(tableauDeComparaison){consthash=newSet(tableauDeComparaison);returnthis.filter(elem=>!hash.has(elem));}}

Privilégier la programmation fonctionnelle à la programmation impérative

constsortieDuProgrammeur=[{nom:"Oncle Bobby",linesDeCode:500},{nom:"Suzie Q",linesDeCode:1500},{nom:"Jimmy Gosling",linesDeCode:150},{nom:"Gracie Hopper",linesDeCode:1000}];letsortieTotale=0;for(leti=0;i<sortieDuProgrammeur.length;i++){sortieTotale+=sortieDuProgrammeur[i].linesDeCode;}

constsortieDuProgrammeur=[{nom:"Oncle Bobby",linesDeCode:500},{nom:"Suzie Q",linesDeCode:1500},{nom:"Jimmy Gosling",linesDeCode:150},{nom:"Gracie Hopper",linesDeCode:1000}];constsortieTotale=sortieDuProgrammeur.reduce((linesTotal,sortie)=>linesTotal+sortie.linesDeCode,0);

Encapsuler des conditions

if(fsm.state==="chercher"&&estVide(listNode)){// ...}

functiondevraitMontrerSpinner(fsm,listNode){returnfsm.state==="chercher"&&estVide(listNode);}if(devraitMontrerSpinner(fsmInstance,listNodeInstance)){// ...}

Éviter les conditionnels négatifs

functionDOMNodeNestPasPrésent(node){// ...}if(!DOMNodeNestPasPrésent(node)){// ...}

functionestDOMNodePresent(node){// ...}if(estDOMNodePresent(node)){// ...}

Éviter les conditionnels

classAvion{// ...obtenirAltitudeDeCroisière(){switch(this.type){case"777":returnthis.obtenirAltitudeMax()-this.obtenirLeNombreDePassagers();case"Air Force One":returnthis.obtenirAltitudeMax();case"Cessna":returnthis.obtenirAltitudeMax()-this.obtenirDépensesDeCarburant();}}}

classAvion{// ...}classBoeing777extendsAvion{// ...obtenirAltitudeDeCroisière(){returnthis.obtenirAltitudeMax()-this.obtenirLeNombreDePassagers();}}classAirForceOneextendsAvion{// ...obtenirAltitudeDeCroisière(){returnthis.obtenirAltitudeMax();}}classCessnaextendsAvion{// ...obtenirAltitudeDeCroisière(){returnthis.obtenirAltitudeMax()-this.obtenirDépensesDeCarburant();}}

Éviter la vérification de type (partie 1)

functionvoyagerAuTexas(véhicule){if(véhiculeinstanceofvélo){véhicule.pédale(this.localisationActuelle,newLocation("texas"));}elseif(véhiculeinstanceofvoiture){véhicule.conduire(this.localisationActuelle,newLocation("texas"));}}

functionvoyagerAuTexas(véhicule){véhicule.déplacer(this.localisationActuelle,newLocation("texas"));}

Éviter la vérification de type (partie 2)

functioncombiner(val1,val2){if((typeofval1==="number"&&typeofval2==="number")||(typeofval1==="string"&&typeofval2==="string")){returnval1+val2;}thrownewError("Doit être de type String ou Number");}

functioncombiner(val1,val2){returnval1+val2;}

Ne pas trop optimiser

// Sur les anciens navigateurs, chaque itération avec `list.length` non mis en cache serait coûteuse// à cause du recalcul de `list.length`. Dans les navigateurs modernes, cela est optimisé.for(leti=0,len=list.length;i<len;i++){// ...}

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

Supprimer le code mort

functionancienModuleDeDemande(url){// ...}functionnouveauModuleDeDemande(url){// ...}constreq=nouveauModuleDeDemande;traqueurInventaire("pommes",req,"www.inventory-awesome.io");

functionnouveauModuleDeDemande(url){// ...}constreq=nouveauModuleDeDemande;traqueurInventaire("pommed",req,"www.inventory-awesome.io");

Objets et Structures De Données

Utilisez des getters et des setters

functionfaireUnCompteBancaire(){// ...return{bilan:0// ...};}constcompte=faireUnCompteBancaire();compte.bilan=100;

functionfaireUnCompteBancaire(){// celui-ci est privéletbilan=0;// un "getter", rendu public via l'objet renvoyé ci-dessousfunctionobtenirLeBilan(){returnbilan;}// un "setter", rendu public via l'objet retourné ci-dessousfunctionfixerLeBilan(montante){// ... valider avant de mettre à jour le soldebilan=montante;}return{// ...    obtenirLeBilan,    fixerLeBilan};}constcompte=faireUnCompteBancaire();compte.fixerLeBilan(100);

Faire en sorte que les objets aient des membres privés

constEmployé=function(nom){this.nom=nom;};Employé.prototype.obtenirNom=functionobtenirNom(){returnthis.nom;};constemployé=newEmployé("John Doe");console.log(`Nom de l'employé:${employé.obtenirNom()}`);// Nom de l'employé: John Doedeleteemployé.nom;console.log(`Nom de l'employé:${employé.obtenirNom()}`);// Nom de l'employé: undefined

functionfaireEmployé(nom){return{obtenirNom(){returnnom;}};}constemployé=faireEmployé("John Doe");console.log(`Nom de l'employé:${employé.obtenirNom()}`);// Nom de l'employé: John Doedeleteemployé.nom;console.log(`Nom de l'employé:${employé.obtenirNom()}`);// Nom de l'employé: undefined

Classes

Préférez les classes ES2015 / ES6 aux fonctions simples de ES5

constAnimale=function(âge){if(!(thisinstanceofAnimale)){thrownewError("Instancier Animal avec `new`");}this.âge=âge;};Animale.prototype.bouger=functionbouger(){};constMammifère=function(age,couleurDefourrure){if(!(thisinstanceofMammifère)){thrownewError("Instancier Mammifère avec `new`");}Animale.appel(this,âge);this.couleurDefourrure=couleurDefourrure;};Mammifère.prototype=Object.create(Animale.prototype);Mammifère.prototype.constructor=Mammifère;Mammifère.prototype.naissanceVivante=functionnaissanceVivante(){};constHumain=function(âge,couleurDefourrure,langueParlée){if(!(thisinstanceofHumain)){thrownewError("Instancier Humain avec `new`");}Mammifère.appel(this,âge,couleurDefourrure);this.langueParlée=langueParlée;};Humain.prototype=Object.create(Mammifère.prototype);Humain.prototype.constructor=Humain;Humain.prototype.parler=functionparler(){};

classAnimale{constructor(âge){this.âge=âge;}bouger(){/* ... */}}classMammifèreextendsAnimale{constructor(âge,couleurDefourrure){super(âge);this.couleurDefourrure=couleurDefourrure;}naissanceVivante(){/* ... */}}classHumainextendsMammal{constructor(âge,couleurDefourrure,languageSpoken){super(âge,couleurDefourrure);this.languageSpoken=languageSpoken;}parler(){/* ... */}}

Utiliser la méthode de chaînage

classVoiture{constructor(marque,modèle,couleur){this.marque=marque;this.modèle=modèle;this.couleur=couleur;}fixerLaMarque(marque){this.marque=marque;}fixerLaModèle(modèle){this.modèle=modèle;}fixerLaCouleur(couleur){this.couleur=couleur;}enregistrer(){console.log(this.marque,this.modèle,this.couleur);}}constvoiture=newVoiture("Ford","F-150","rouge");voiture.fixerLaCouleur("rose");voiture.enregistrer();

classVoiture{constructor(marque,modèle,couleur){this.marque=marque;this.modèle=modèle;this.couleur=couleur;}fixerLaMarque(marque){this.marque=marque;// NOTE: Renvoyer ceci pour chaînerreturnthis;}fixerLaModèle(modèle){this.modèle=modèle;// NOTE: Renvoyer ceci pour chaînerreturnthis;}fixerLaCouleur(couleur){this.couleur=couleur;// NOTE: Renvoyer ceci pour chaînerreturnthis;}enregistrer(){console.log(this.marque,this.modèle,this.couleur);// NOTE: Returning this for chainingreturnthis;}}constvoiture=newVoiture("Ford","F-150","rouge").fixerLaCouleur("rose").enregistrer();

Préfère la composition à l'héritage

classEmployé{constructor(nom,email){this.nom=nom;this.email=email;}// ...}// Bad because Employees "have" tax data. EmployeeTaxData is not a type of EmployeeclassDonnéesFiscalesDuEmployéextendsEmployé{constructor(ssn,salaire){super();this.ssn=ssn;this.salaire=salaire;}// ...}

classDonnéesFiscalesDuEmployé{constructor(ssn,salaire){this.ssn=ssn;this.salaire=salaire;}// ...}classEmployé{constructor(nom,email){this.nom=nom;this.email=email;}définirDonnéesFiscales(ssn,salaire){this.donnéesFiscales=newDonnéesFiscalesDuEmployé(ssn,salaire);}// ...}

SOLID

Principe de responsabilité unique (PRU)

classParamètresUtilisateur{constructor(utilisateur){this.utilisateur=utilisateur;}changerParamètres(paramètres){if(this.vérifierIdentifications()){// ...}}vérifierIdentifications(){// ...}}

classAuthentificationUtilisateur{constructor(utilisateur){this.utilisateur=utilisateur;}vérifierIdentifications(){// ...}}classParamètresUtilisateur{constructor(utilisateur){this.utilisateur=utilisateur;this.auth=newAuthentificationUtilisateur(utilisateur);}changerParamètres(paramètres){if(this.auth.vérifierIdentifications()){// ...}}}

Principe Ouvert / Fermé (POF)

classAdaptateurAjaxextendsAdaptateur{constructor(){super();this.nom="adaptateurAjax";}}classAdaptateurNodeextendsAdaptateur{constructor(){super();this.nom="adaptateurNode";}}classRequêtementHttp{constructor(adaptateur){this.adaptateur=adaptateur;}fetch(url){if(this.adaptateur.nom==="adaptateurAjax"){returnfaireAppelAjax(url).then(réponse=>{// transformer la réponse et le retour});}elseif(this.adaptateur.nom==="adaptateurNode"){returnfaireAppelHttp(url).then(réponse=>{//transformer la réponse et le retour});}}}functionfaireAppelAjax(url){// demande et retour promesse}functionfaireAppelHttp(url){// demande et retour promesse}

classAdaptateurAjaxextendsAdaptateur{constructor(){super();this.nom="adaptateurAjax";}demande(url){// demande et retour promesse}}classAdaptateurNodeextendsAdaptateur{constructor(){super();this.nom="adaptateurNode";}demande(url){// demande et retour promesse}}classRequêtementHttp{constructor(adaptateur){this.adaptateur=adaptateur;}rapporter(url){returnthis.adaptateur.demande(url).then(réponse=>{//transformer la réponse et le retour});}}

Principe de substitution de Liskov (PSL)

classRectangle{constructor(){this.largeur=0;this.taille=0;}définirLaCouleur(couleur){// ...}rendre(surface){// ...}définirLaLargeur(largeur){this.largeur=largeur;}définirLaTaille(taille){this.taille=taille;}avoireLaSurface(){returnthis.largeur*this.taille;}}classCarréextendsRectangle{définirLaLargeur(largeur){this.largeur=largeur;this.taille=largeur;}définirLaTaille(taille){this.largeur=taille;this.taille=taille;}}functionrendreLesGrandsRectangles(rectangles){rectangles.forEach(rectangle=>{rectangle.définirLaLargeur(4);rectangle.définirLaTaille(5);constsurface=rectangle.avoireLaSurface();// BAD: renvoie 25 pour Square. Devrait être 20.rectangle.rendre(surface);});}constrectangles=[newRectangle(),newRectangle(),newCarré()];rendreLesGrandsRectangles(rectangles);

classForme{définirLaCouleur(couleur){// ...}rendre(surface){// ...}}classRectangleextendsForme{constructor(largeur,taille){super();this.largeur=largeur;this.taille=taille;}avoireLaSurface(){returnthis.largeur*this.taille;}}classCarréextendsForme{constructor(longeur){super();this.longeur=longeur;}getArea(){returnthis.longeur*this.longeur;}}functionrendreLesGrandesFormes(formes){formes.forEach(forme=>{constsurface=forme.avoireLaSurface();forme.rendre(surface);});}constformes=[newRectangle(4,5),newRectangle(4,5),newSquare(5)];rendreLesGrandesFormes(formes);

Principe de séparation des interfaces (ISP)

classDOMTraverser{constructor(réglages){this.réglages=réglages;this.installer();}installer(){this.rootNode=this.réglages.rootNode;this.moduleDAnimation.installer();}traverse(){// ...}}const$=newDOMTraverser({rootNode:document.getElementsByTagName("body"),moduleDAnimation(){}// La plupart du temps, nous n'avons pas besoin d'animer lorsque vous traversez.// ...});

classDOMTraverser{constructor(réglages){this.réglages=réglages;this.options=réglages.options;this.installer();}installer(){this.rootNode=this.réglages.rootNode;this.optionsInstallation();}setupOptions(){if(this.options.moduleDAnimation){// ...}}traverse(){// ...}}const$=newDOMTraverser({rootNode:document.getElementsByTagName("body"),options:{moduleDAnimation(){}}});

Principe d'inversion de dépendance (DIP)

classDemandeurInventaire{constructor(){this.REQ_METHODS=["HTTP"];}demanderUnArticle(article){// ...}}classSuiviInventaire{constructor(articles){this.articles=articles;// BAD: Nous avons créé une dépendance sur une implémentation de requête spécifique.// On devrait juste avoir demanderUnArticles dépendent d'une méthode de requête: `request`this.demandeur=newDemandeurInventaire();}demanderDesArticles(){this.articles.forEach(article=>{this.demandeur.demanderUnArticle(article);});}}consttraqueurInventaire=newSuiviInventaire(["pommes","bananes"]);traqueurInventaire.demanderDesArticles();

classSuiviInventaire{constructor(articles,demandeur){this.articles=articles;this.demandeur=demandeur;}demanderDesArticles(){this.articles.forEach(article=>{this.demandeur.demanderUnArticle(article);});}}classDemandeurInventaireV1{constructor(){this.REQ_METHODS=["HTTP"];}demanderUnArticle(article){// ...}}classDemandeurInventaireV2{constructor(){this.REQ_METHODS=["WS"];}demanderUnArticle(article){// ...}}// En construisant nos dépendances à l'extérieur et en les injectant, on peut facilement// substitue notre module de requête à un nouveau module utilisant WebSockets.consttraqueurInventaire=newSuiviInventaire(["pommes","bananes"],newDemandeurInventaireV2());traqueurInventaire.demanderDesArticles();

Testage

Concept unique par test

importassertfrom"assert";describe("Rendre MomentJS encore une fois génial",()=>{it("gère les limites de la date",()=>{letdate;date=newRendreMomentJSEncoreUneFoisGénial("1/1/2015");date.addDays(30);assert.equal("1/31/2015",date);date=newRendreMomentJSEncoreUneFoisGénial("2/1/2016");date.addDays(28);assert.equal("02/29/2016",date);date=newRendreMomentJSEncoreUneFoisGénial("2/1/2015");date.addDays(28);assert.equal("03/01/2015",date);});});

importassertfrom"assert";describe("Rendre MomentJS encore une fois génial",()=>{it("gère les mois de 30 jours",()=>{constdate=newRendreMomentJSEncoreUneFoisGénial("1/1/2015");date.ajouterLesJours(30);assert.equal("1/31/2015",date);});it("gère l'année bissextile",()=>{constdate=newRendreMomentJSEncoreUneFoisGénial("2/1/2016");date.ajouterLesJours(28);assert.equal("02/29/2016",date);});it("gère l'année non bissextile",()=>{constdate=newRendreMomentJSEncoreUneFoisGénial("2/1/2015");date.ajouterLesJours(28);assert.equal("03/01/2015",date);});});

Simultanéité

Utilisez des promesses, pas des rappels

import{get}from"request";import{writeFile}from"fs";get("https://en.wikipedia.org/wiki/Robert_Cecil_Martin",(errDemande,réponse)=>{if(errDemande){console.error(errDemande);}else{writeFile("article.html",réponse.body,writeErr=>{if(writeErr){console.error(writeErr);}else{console.log("Fichier écrit");}});}});

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

Async / Await sont encore plus propres que Promises

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

import{get}from"request-promise";import{writeFile}from"fs-promise";asyncfunctionobtenirUnArticleDeCodePropre(){try{constresponse=awaitget("https://en.wikipedia.org/wiki/Robert_Cecil_Martin");awaitwriteFile("article.html",réponse);console.log("Fichier écrit");}catch(err){console.error(err);}}

La Gestion des Erreurs

Ne pas ignorer les erreurs interceptées

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

try{fonctionQuiPourraitJeter();}catch(error){// Une option (plus bruyante que console.log):console.error(error);// Une autre option:notifierUtilisateurDuErreur(error);// Une autre option:signalerAuServiceDuErreur(error);// OU faire tous les trois!}

Ne pas ignorer les promesses rejetées

getdata().then(données=>{fonctionQuiPourraitJeter(données);}).catch(error=>{console.log(error);});

getdata().then(données=>{fonctionQuiPourraitJeter(données);}).catch(error=>{// Une option (plus bruyante que console.log):console.error(error);// Une autre option:notifierUtilisateurDuErreur(error);// Une autre option:signalerAuServiceDuErreur(error);// OU faire tous les trois!});

Mise En Forme

Utilisez une capitalisation cohérente

constJOURS_PAR_SEMAINE=7;constjoursParMois=30;constchansons=["Back In Black","Stairway to Heaven","Hey Jude"];constArtists=["ACDC","Led Zeppelin","The Beatles"];functioneffacerLeDatabase(){}functionrestaurer_Ledatabase(){}classanimale{}classAlpaga{}

constJOURS_PAR_SEMAINE=7;constJOURS_PAR_MOIS=30;constCHANSONS=["Back In Black","Stairway to Heaven","Hey Jude"];constARTISTS=["ACDC","Led Zeppelin","The Beatles"];functioneffacerLeDatabase(){}functionrestaurerLeDatabase(){}classAnimale{}classAlpaga{}

Les appelants et les correspondants doivent être rapprochés

classExamenDuRendement{constructor(employé){this.employé=employé;}lookupCollègues(){returndb.lookup(this.employé,"collègues");}lookupDirecteur(){returndb.lookup(this.employé,"directeur");}obtenirEvaluationsDesCollègues(){constcollègues=this.lookupCollègues();// ...}examenDuRendement(){this.obtenirEvaluationsDesCollègues();this.obtenirEvaluationsDuDirecteur();this.obtenirEvaluationDeSoi();}obtenirEvaluationsDuDirecteur(){constmanager=this.lookupDirecteur();}obtenirEvaluationDeSoi(){// ...}}constevaluation=newExamenDuRendement(employé);evaluation.examenDuRendement();

classExamenDuRendement{constructor(employé){this.employé=employé;}examenDuRendement(){this.obtenirEvaluationsDesCollègues();this.obtenirEvaluationsDuDirecteur();this.obtenirEvaluationDeSoi();}obtenirEvaluationsDesCollègues(){constcollègues=this.lookupCollègues();// ...}lookupCollègues(){returndb.lookup(this.employé,"collègues");}obtenirEvaluationsDuDirecteur(){constmanager=this.lookupDirecteur();}lookupDirecteur(){returndb.lookup(this.employé,"directeur");}obtenirEvaluationDeSoi(){// ...}}constevaluation=newExamenDuRendement(employé);evaluation.examenDuRendement();

Commentaires

Ne commentez que les choses qui ont une complexité de logique métier.

functionhasher(données){// La hashlethash=0;// Longeur du stringconstlongeur=données.longeur;// Boucle à travers chaque caractère dans les donnéesfor(leti=0;i<length;i++){// Obtenez le code de caractère.constchar=données.charCodeAt(i);// Faire le hashhash=(hash<<5)-hash+char;// Convertir en entier 32 bitshash&=hash;}}

functionhasher(données){lethash=0;constlongeur=données.longeur;for(leti=0;i<length;i++){constchar=données.charCodeAt(i);hash=(hash<<5)-hash+char;// Convertir en entier 32 bitshash&=hash;}}

Ne laissez pas de code commenté dans votre base de code

faireUneChose();// faireAutreChoses();// faireEncoreAutreChoses();// faireTropDeChoses();

faireUneChose();

Je n'ai pas de commentaires dans le journal

/** * 2016-12-20: Monades supprimées, je ne les ai pas comprises (RM) * 2016-10-01: Amélioration de l'utilisation de monades spéciales (JP) * 2016-02-03: Suppression de la vérification de type (LI) * 2015-03-14: Ajout d'une combinaison avec la vérification de type (JR) */functioncombiner(a,b){returna+b;}

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

Évitez les marqueurs de position

////////////////////////////////////////////////////////////////////////////////// Instanciation du modèle de portée////////////////////////////////////////////////////////////////////////////////$scope.model={menu:"foo",nav:"bar"};////////////////////////////////////////////////////////////////////////////////// Configuration de l'action////////////////////////////////////////////////////////////////////////////////constactions=function(){// ...};

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

Traduction