Regardez les différences dans la programmation JavaScript ici la programmation orientée objet et fonctionnelle par code.

Auteur | Jesse Warden

Traducteur | ménisque, Zebian | Guo Rui

Produit | RPSC ( ID: CSDNnews)

Ce qui suit est la traduction:

Un collègue m'a posé des questions sur la forme d'organisation du code de programmation fonctionnelle. Il utilise Node avec un groupe de développeurs Java travaillant sur un projet AWS Lambda, ils utilisent le même type de catégorie, divers modèles de conception et d'autres organisations du code de programmation orienté objet de cette façon. Il voulait savoir si elles utilisent uniquement la fonction pure dans la programmation fonctionnelle, alors ils devraient être comment l'organiser?

mode de programmation orienté objet

Je me sens le plus profond est, tout le monde sous la forme d'organisation du code est différent. Entre les différentes langues, la pratique n'acceptée est d'avoir une interface commune pour les tests. Interface publique fait référence au grand nombre d'interfaces abstraites pour les détails internes. Il est peut-être une méthode de classe publique, ou peut-être Façade modèle de conception d'usine peut aussi être un module de fonction. Ces trois utiliseront un certain nombre de fonctions internes, mais la fonction ouvrira un appel. Parfois, cette approche peut faire en sorte que, après l'ajout de fonctionnalités et de corrections bug, les consommateurs dans la dernière mise à jour du code sans modifier le code. Bien sûr, cet effet secondaire aura encore un impact négatif.

module de classe unique

On peut dire, au moins dans l'approche nud, l'orienté objet comprend généralement deux modèles de conception de base. La première méthode consiste à créer une classe, puis exporter le public comme la valeur par défaut:

// CommonJS classe QUELQUE CHOSE {...} module.exports = something // ES6 classe QUELQUE CHOSE {...} l'exportation par défaut QUELQUE CHOSE

Exporter plusieurs choses

La deuxième méthode est d'ouvrir beaucoup de choses du même module, y compris les classes, fonctions, variables et autres événements:

// CommonJS classe QUELQUE CHOSE {...} const = = utilFunction >  ... const CONFIGURATION_VAR = ... module.exports = { QUELQUE CHOSE, utilFunction, CONFIGURATION_VAR } // ES6 classe d'exportation {...} QUELQUE CHOSE export const utilFunction = = >  ... export const CONFIGURATION_VAR = ...

En plus de ces deux méthodes de base pour exporter le code, la situation sera différente pour chaque projet et chaque équipe varie vers le haut. Certains projets ou équipes peuvent utiliser différents cadres, tels que l'utilisation de Nest Express et utiliser le code différent de l'équipe. Exprimez même utiliser le même cadre, utilisez les deux équipes est également différente. Parfois, organisé Express dans le nouveau projet dans la même équipe ne sont pas nécessairement les mêmes que les précédents projets.

Mode de programmation fonctionnelle

Mode de programmation fonctionnelle organisation du code, au moins dans le nud, il y a deux modes.

Exporter une fonction

La deuxième façon est d'exporter une fonction d'un module:

// CommonJS const = = utilFunction >  ... module.exports = utilFunction // ES6 const = = utilFunction >  ... l'exportation par défaut utilFunction

Exporter plusieurs fonctions

Le deuxième mode de réalisation est dérivée d'une pluralité de modules fonctionnels:

// CommonJS const = = utilFunction >  ... const = = anotherHelper >  ... module.exports = { utilFunction, anotherHelper } // ES6 export const utilFunction = = >  ... exporter const anotherHelper = = >  ...

Variable?

Certaines personnes vont dériver des variables et les fonctions de la même manière, et certaines personnes préfèrent la pure fonction de calcul de retard ou un défenseur exportera fonctions:

// pragmatique export CONFIGURATION_THING = 'une valeur' // puriste exporter configurationThing = = >  « Une valeur »

Exemples

Nous avons créé quelques exemples pour le code ci-dessus pour vous montrer comment utiliser l'exportation unique et multiple. Nous orienté objet et construit la programmation fonctionnelle d'une interface commune, et pour l'instant ignorer les effets secondaires des deux (c.-à- HTTP Appel), on suppose l'unité de test utilisera cette interface commune pour appeler les méthodes privées à l'intérieur. Les deux vont se charger et analyser le même texte.

Les deux exemples analyser la chaîne JSON:

<{ "firstname": "jesse" "lastname": "gardien" "type": "human" } { "firstname": "albus" "lastname": "dumbledog" "type": "chien" } { "firstname": "cognac" "lastname": "fortune" "type": "human" }>

Exemple: La programmation orientée objet

Nous avons besoin de trois classes: une classe par encodage par défaut pour lire le fichier, une classe est responsable de l'analyse du type de fichier, une classe singleton en les combinant dans une interface commune.

readfile.js

Tout d'abord, le code lit ce fichier qui va lire des fichiers pour réaliser la promesse, soutenir un paramètre optionnel d'encodage:

// readfile.js fs à l'importation de « » fs import {} EventEmitter des 'événements' classe ReadFile { readFile (filename, encoding = default_encoding) { retour nouvelle promesse (fonction (succès, échec) { fs.readFile (nom de fichier, le codage, la fonction (l'erreur, des données) { si (erreur) { échec (erreur) retour } succès (données) }) }) } } export default_encoding = 'utf8' exportation ReadFile

parser.js

Ensuite, nous avons besoin d'une classe d'analyseur, obtenir les données chaîne originale lues à partir du fichier et détermination à Array:

// parser.js import {} startCase de 'lodash' classe parseFile { #fileData #names obtenir les noms { retourner ce. # noms } constructeur (data) { cela. # fileData = données } parseFileContents { laisser les gens = JSON.parse (cela. # fileData) cela. # names = soit p pour (p = 0; p <  Personnes.Length; p ++) { personne const = personnes

si (person.type === 'humain') { Nom const = this._personToName (personne) names.push (nom) } } } _personToName (personne) { Nom const = `$ {person.firstName} $ {}` person.lastName retour startCase (nom) } } l'exportation par défaut parseFile

index.js

Enfin, nous avons besoin d'un singleton les combiner en une méthode statique:

// index.js importation parseFile de « ./parsefile » {import ReadFile, default_encoding} de './readfile' classe PeopleParser { statique async getPeople { try { lecteur const = new ReadFile const fileData = await reader.readFile ( 'people.txt', default_encoding) analyseur const = new parseFile (data) parser.parseFileContents parser.names de retour } Catch (error) { console.error (erreur) } } } l'exportation par défaut PeopleParser

Appelez la méthode statique de PeopleParser

Appel comme suit:

importation PeopleParser de « ./peopleparser » PeopleParser.getPeople .alors (console.log) .catch (console.error)

La structure du dossier final suit comme:

Enfin, vous pouvez PeopleParser système de fichiers de test unitaire.

Exemple: Programmation fonctionnelle

Par exemple la programmation fonctionnelle, vous pouvez vous référer à cet article ( http : // jessewarden .com /2019/01/four-ways-to-compose-synchronous-functions-in-javascript.html). Nous avons juste besoin d'une série de fonctions:

La fonction d'encodage par défaut

exporter const getDefaultEncoding = = > 'Utf8'

Fonction pour lire le fichier

const = readFile fsModule = >  encoding = >  filename = > Promesse nouvelle ((succès, échec) = > fsModule.readFile (nom de fichier, le codage, (erreur, des données) = > erreur ? Échec (erreur) : Succès (données) )

Fonction fichiers parse

const parseFile = data = > Promesse nouvelle ((succès, échec) = >  { try { résultat const = JSON.parse (données) résultat retour } Catch (error) { erreur retour } })

fonction de filtrage humain d'un peuple de sujet

const = filterHumans peeps = > peeps.filter ( personne = > person.type === 'humain' )

chaîne de format humain du nom de la fonction dans la liste

const = nomsFormats humains = > humans.map ( = homme > `$ {Human.firstName} $ {}` human.lastName )

Modifier le nom de l'affaire de la liste et la fonction cartographie

const startCaseNames = names = > names.map (startCase)

Fournir une fonction d'interface commune

exporter const getPeople = fsModule = >  encoding = >  filename = > readFile (fsModule) (codage) (nom de fichier) .alors (parseFile) .Puis (filterHumans) .Puis (nomsFormats) .alors (startCaseNames)

appel getPeople

L'appel de la fonction affichée de la manière suivante:

fs à l'importation de « » fs {import getPeople, getDefaultEncoding} de './peopleparser' getPeople (fs) (getDefaultEncoding) ( '') people.txt .alors (console.log) .catch (console.error)

Enfin, la structure du dossier est la suivante:

Enfin, vous pouvez utiliser la pile de getPeople test fs.

résumé

Comme indiqué plus haut, à la fois la programmation orientée objet ou la programmation fonctionnelle, vous pouvez utiliser CommonJS et la façon de parvenir à l'exportation par défaut ES6, peut également réaliser plusieurs exportations. Tant que vous exportez les détails de mise en uvre de peau de l'interface publique, vous pouvez utiliser le code pour assurer qu'aucun dommage lorsque la mise à jour du peuple, mais aussi pour assurer les détails de mise en uvre pour modifier les méthodes / fonctions de classe privées sans avoir à reconstruire un groupe d'unités test.

Bien que la programmation fonctionnelle exemplaire ici moins que le code orienté objet, mais ne confondez pas, la programmation fonctionnelle peut contenir de nombreuses fonctions, et vous pouvez utiliser la même manière - d'un module / fichier ou une série de fonctions exporter une fonction. Habituellement, vous pouvez le dossier index.js que l'exportation réelle d'interface commune.

Original: https: // dzone .com / Articles / code-organisation en programmation fonctionnelle-vs-obj

Cet article traduction RPSC, s'il vous plaît indiquer la source de la source.

[FIN]