Gestion des erreurs avec les promesses

# Promises, async/await et erreurs

---

# Les bases de la gestion des erreurs
      
```      
function asyncRandom(n) {
      
	return new Promise((resolve, reject) => {
        setTimeout(() => {
      
          if (Math.random() > .5)
      		return resolve(Math.random() * n);
      
          reject("Je ne veux pas travailler, je ne veux pas t'écouter, etc.");
      
        }, 1000);
    });
}   
```

---
      
# Code appelant
 
```
let p = new asyncRandom(42);
p.then(r => new asyncRandom(r))
 .then(r => {
    console.log('yup', r);
  });
```
      
---
      
# Gérer les erreurs avec le second argument de "then"
 
```
let p = new asyncRandom(42);
p.then(
	r => new asyncRandom(r),
    err => {
    	console.log('oh noes!', err);
    }
).then(
	r => {
    	console.log('yup', r);
    },
    err => {
      	console.log('wat?', err);
    }
);
```
      
???
      
On me dit qu'il y a des développeurs Java dans la salle, mettons en place des design patterns et factorisons le code...
      
---
      
# Factorisons !
 
```
function GenericErrorHandlerSingletonProxyFactory(err) {
    console.log('an error occurred!', err);
}
let p = new asyncRandom(42);
p.then(
	r => new asyncRandom(r),
    GenericErrorHandlerSingletonProxyFactory
).then(
	r => {
    	console.log('yup', r);
    },
    GenericErrorHandlerSingletonProxyFactory
);
```
      
???
      
Bien, mais d'ou vient l'erreur ?
      
---

# Conseil #1: Reject renvoye idéalement une Error
           
```      
function asyncRandom(n) {
      
	return new Promise((resolve, reject) => {
        setTimeout(() => {
      
          if (Math.random() > .5)
      		return resolve(Math.random() * n);
      
          reject(new Error("Je ne veux pas travailler, etc."));
      
        }, 1000);
    });
}   
``` 
      
???
      
Comme ça le handler peut avoir accès à .stack, .message, etc.
      
---
      
# 'throw' dans la Promise
      
```      
function asyncRandom(n) {
      
	return new Promise((resolve, reject) => {
        setTimeout(() => {
      
          if (Math.random() > .5)
      		return resolve(Math.random() * n);
      
          throw new Error("Je ne veux pas travailler, etc.");
      
        }, 1000);
    });
}   
``` 
      
???
      
L'erreur sera attrapée comme si on avait appelé "reject" avec l'erreur en question.

--- 
      
# L'erreur quand tout se passe bien
      
```
function GenericErrorHandlerSingletonProxyFactory(err) {
    console.log('an error occurred!', err.stack, err.message);
}
let p = new asyncRandom(42);
p.then(
	r => new asyncRandom(r),
    GenericErrorHandlerSingletonProxyFactory
).then(
	r => {
    	console.fog('yup', r);
    },
    GenericErrorHandlerSingletonProxyFactory
);
```
- Affiche: rien du tout...
      
???
      
Pourquoi ? Il y a une faute dans le script, et par défaut avec les promises,
les erreurs non attrapées explicitement se font "avaler" par le moteur JS !

---

# Les erreurs non attrapées explicitement se font "avaler" !
      
---
      
# Conseil #2: Toujours utiliser .catch en fin de chaîne
    
```
let p = new asyncRandom(42);
p.then(
	r => new asyncRandom(r),
    GenericErrorHandlerSingletonProxyFactory
).then(
	r => {
    	console.fog('yup', r);
    },
    GenericErrorHandlerSingletonProxyFactory
).catch(err => {
	console.log('Caught error in promise or resolve() code:', err.message);
});
```
      
???
      
.catch récupère les erreurs provoquées par les rejections et dans les resolve handlers.
      
---
     
# Plus besoin du second argument de then
      
```
let p = new asyncRandom(42);
p.then(r => new asyncRandom(r))
 .then(r => {
	console.fog('yup', r);
  })
 .catch(err => {
	console.log('Caught error in promise or resolve() code:', err.message);
 });
```
      
---

# Quid d'async/await ?
      
???
      
Sucre syntaxique sur des Promises => même problématique.
      
---

# Les erreurs non attrapées explicitement se font "avaler" !
      
---
      
# try/catch
      
```
try {
  	let r = await asyncRandom(42);
  	r = await asyncRandom(r);
  	console.log('yup', r);
} catch(err) {
    console.log('an error occurred!', err);
}
```

???
      
Sucre syntaxique pour .catch() => toutes les erreurs, même dans le code synchrone, sont attrapées.
      
---

# async/await et chaîne d'appels

```
// can throw!
async function randomSquare() {
	return (await asyncRandom(1)) * (await asyncRandom(1));
}
      
console.log(await randomSquare());
```
      
---
      
# Conseil #3: Toujours try/catch sur l'appel asynchrone le plus haut!
  
```
try {
    await randomSquare();
} catch(err) {
    console.log('an error occurred!', err);
}
```
      
---

# Merci de votre attention

## .link[[@bnjbvr](https://twitter.com/bnjbvr)]

???

Commentaires