Réflexions après avoir lu 'Programmation fonctionnelle JavaScript'_compétences javascript

Cet article enregistre certaines des choses que j'ai comprises en apprenant des expressions fonctionnelles, pour approfondir ma mémoire, les organiser et les enregistrer pour une révision ultérieure.

J'ai pris ma décision en voyant le livre "JavaScript Functional Programming" en prévente récemment. Le but principal est que je ne comprends toujours pas ce qu'est la programmation fonctionnelle. Au cours de mon propre apprentissage, j'ai toujours entendu des gens autour de moi parler de programmation orientée processus et de programmation orientée objet, mais il existe très peu de programmation fonctionnelle. Afin de ne pas prendre de retard sur les autres étudiants, je souhaitais partager et enregistrer les connaissances acquises en lisant en écrivant des notes.

js et programmation fonctionnelle

Le livre utilise une phrase simple pour répondre à ce qu'est la programmation fonctionnelle :

La programmation fonctionnelle utilise des fonctions pour convertir des valeurs en unités abstraites, qui sont ensuite utilisées pour créer des systèmes logiciels.
Je pense qu'il doit y avoir des étudiants qui lisent cette phrase et ne savent toujours pas grand-chose de ce qu'est la programmation fonctionnelle et pourquoi nous devrions utiliser la programmation fonctionnelle. La plupart des exemples suivants utilisent le trait de soulignement.

Utiliser des fonctions comme unités abstraites

Les méthodes abstraites font référence à des fonctions qui masquent les détails. Prenons un exemple tiré du livre, une fonction qui détecte la valeur d'âge de sortie (principalement rapporte les erreurs et les avertissements) :

function parseAge(age) {
  if (!_.isString(age))
    throw new Error("Expecting a string");
  var a;
  console.log("Attempting to parse an age");

  a = parseInt(age, 10);
  if (_.isNaN(a)) {
    console.log(["Could not parse age: "].join());
    a = 0;
  }

  return a;
}

La fonction ci-dessus détermine si nous avons saisi un âge, et il doit être sous la forme d'une chaîne. L'étape suivante consiste à exécuter cette fonction :

parseAge("42"); //=> 42
parseAge(42); //=> Error:Expecting a string
parseAge("hhhh"); //=> 0

La fonction parseAge ci-dessus fonctionne correctement sans aucun problème. Si nous voulons changer la façon dont les erreurs de sortie = les informations et les avertissements sont présentés, nous devons alors modifier les lignes de code correspondantes, ainsi que le mode de sortie ailleurs. La méthode donnée dans le livre est obtenue en les abstractionnant en différentes fonctions :

function fail(thing) {
  throw new Error(thing);
}

function warn(thing) {
  console.log(["WARNING:", thing].join(''));
}

function note(thing) {
  console.log(["NOTE:", thing].join(''));
}

Utilisez ensuite la fonction ci-dessus pour reconstruire la fonction parseAge.

funciton parseAge(age) {
  if (!_.isString(age))
    fail("Expecting a string");
  var a;

  note("Attempting to parse an age");
  a = parseInt(age, 10);

  if (_.isNaN(a)) {
    warn(["Could not parse age:", age].join(""));
    a = 0;
  }

  return a;
}

Mettez le code qui signale les erreurs dans différentes fonctions, et le parseAge refactorisé n'a pas beaucoup changé par rapport au précédent. Mais la différence est que désormais l’idée de signaler les erreurs, les messages et les avertissements a été abstraite. Le reporting des erreurs, messages et avertissements a également été entièrement repensé.

Ce que cela fait, c'est que puisque le comportement est contenu dans une seule fonction, la fonction peut être remplacée par une nouvelle fonction qui fournit un comportement similaire, ou directement remplacée par un comportement complètement différent.

Encapsulation et dissimulation

Ce titre est facile à comprendre, voici un exemple. Nous utilisons souvent la vie pour éviter la pollution mondiale. C'est un bon exemple d'encapsulation et de dissimulation. En utilisant iife pour masquer certaines variables et méthodes que vous écrivez, le but n'est pas de polluer l'environnement global. Cela utilise également des fermetures pour masquer les données.

Parce que la fermeture est aussi une fonction. Et cela a beaucoup à voir avec l’apprentissage de la programmation fonctionnelle maintenant. Mais n’oubliez pas l’encapsulation orientée objet que vous avez apprise auparavant. Après tout, vous ne pouvez pas dire qui est le meilleur entre les deux. Mais ce n’est pas une mauvaise chose si vous les maîtrisez tous. Comme le dit le vieil adage : regardez la demande.

Utiliser la fonction comme unité de comportement

Masquer les données et les comportements (généralement peu pratiques pour une modification rapide) n'est qu'une façon de parler des fonctions comme d'unités abstraites. Une autre approche consiste à fournir un moyen simple de stocker et de transférer des comportements de base vers des unités discrètes hors ligne.

Une petite châtaigne dans le livre, utilisant la syntaxe js pour indexer une valeur dans un tableau :

var arr = ['a', 'b', 'c'];
arr[1] //=> b

Bien que l'indexation d'une valeur dans le tableau ci-dessus soit simple, il n'y a aucun moyen d'obtenir ce comportement et de l'utiliser selon les besoins sans la mettre dans une fonction. Écrivez une fonction simple nième pour indexer une valeur dans le tableau :

function nth(a, index) {
  return a[index];
}

Puis exécutez :

nth(arr, 1); //=> L'opération réussit, mais si un objet vide est transmis, une erreur sera signalée. Par conséquent, si nous voulons implémenter l'abstraction de fonction autour de nth, nous pourrions concevoir l'instruction suivante : nth renvoie une fonction valide stockée dans un type de données qui permet l'accès à l'index. La clé de cette affirmation est le concept de type de données d'index. Peut-être qu'une fonction est nécessaire pour déterminer le type :

function isIndexed(data) {
  return _.isArray(data) || _.isString(data);
}

function nth(a, index) {
  if (!_.isNumber(index)) 
    fail("Expected a number as the index");
  if (!isIndexed(a))
    fail("Not supported on non-indexed type");
  if ((index < 0) || (index > a.length - 1))
    fail("Index value is out of bounds");

  return a[index];
}

function second(a) {
  return nth(a, 1);
}

function existy(x) {
  return x != null
}

function truthy(x) {
  return (x !== false) && existy(x);
}

var arr = [1, 2, 3, 4, 5];

// 最快
for (var i = 0; i < arr.length; i++) {
  console.log(arr[i]);
}

// 较慢
_.each(arr, function (val, index) {
  console.log(index);
});