functional-javascript-workshop
Version:
The basics of functional programming in JavaScript. No libraries required.
110 lines (71 loc) • 3.76 kB
Markdown
L’application partielle vous permet de créer de nouvelles fonctions à partir de fonctions existantes, en pré-remplissant tout ou partie de leurs arguments. Une fois les arguments pré-remplis définis, vous obtenez une nouvelle fonction qui n’attend plus que les éventuels arguments restants pour exécuter la fonction d’origine.
Plus formellement : l’application partielle désigne le pré-remplissage d’arguments d’une fonction pour produire une fonction de moindre arité.
À titre d’exemple, imaginons que nous avons une fonction `add()` qui accepte deux arguments et renvoie leur somme :
```js
function add(x, y) {
return x + y
}
add(10, 20) // => 30
```
À présent, imaginons que nous disposons d’une fonction `partiallyApply()`. Celle-ci reçoit une fonction et quelques arguments qu’elle « applique partiellement » (qu’elle pré-remplit, en somme).
Dans le code qui suit, nous pré-remplissons le premier argument de notre fonction `add()`, à savoir `x` :
```js
var addTen = partiallyApply(add, 10) // pré-remplit `x` à 10
```
`addTen()` est une nouvelle fonction, qui n’a plus besoin que du paramètre `y` de `add()`. `add()` n’a pas encore été appelée !
Une fois que nous passons l’argument pour `y`, la fonction `add()` originale peut être appelée :
```js
addTen(20) // => 30
addTen(100) // => 110
addTen(0) // => 10
// etc.
```
Tous les exemples ci-dessus reviennent à appeler `add(10, y)`, ou `y` serait fourni dans l’appel à la bien-nommée `addTen()`.
# Défi
Utilisez l’application partielle pour créer une fonction qui pré-remplit un premier argument pour `console.log()`. En somme, implémentez une fonction de log qui préfixe son message.
Votre implémentation doit accepter une `String` de préfixe, et renvoyer une fonction qui affichera les contenus qu’on lui passe sur la console, préfixée par cette `String`.
Vous aurez besoin de `Function#apply()` pour implémenter l’application partielle.
Assurez-vous que **tous** les arguments passés à la fonction de log (celle renvoyée par la fonction que vous allez écrire) sont bien affichés.
**Affichez le résultat directement sur la console.**
## Arguments
* `namespace` : une `String` qui préfixe les messages passés à la fonction qui sera retournée.
## Exemple
```js
var info = logger('INFO :')
info('ceci est un message d’information')
// INFO : ceci est un message d’information
var warn = logger('WARN :')
warn('ceci est un avertissement', 'avec du rab')
// WARN : ceci est un avertissement avec du rab
```
## Conditions
* N’utilisez pas `Function#bind()`
* Utilisez `Function#apply()`
## Base de travail
```js
var slice = Array.prototype.slice
function logger(namespace) {
// VOTRE SOLUTION ICI
}
module.exports = logger
```
## Ressources
* https://en.wikipedia.org/wiki/Partial_application
* https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/apply
## Conseils
Gardez à l’esprit que `console.log()` accepte un nombre quelconque d’arguments et les affiche, séparés par des espaces :
```js
console.log('bonjour', 'monde') // => 'bonjour monde'
console.log(1, 2, 3) // => 1 2 3
```
Nous voulons simplement pré-remplir le premier argument de `console.log()`.
`Function#apply()` nous permet d’exécuter une fonction, en fournissant une valeur spécifique pour `this` (ce qu’on peut royalement ignorer sur ce coup), puis un **tableau d’arguments à passer à la fonction** :
```js
add(10, 20) // => 30
add.apply(null, [10, 20]) // => 30
```
Faites bien la différence entre `apply()` et `call()` :
```js
add.apply(null, [10, 20]) // => 30
add.call(null, 10, 20) // => 30
```