Fonction de retour => Fonction de rappel

Signed-off-by: Bruno Lesieur <bruno.lesieur@gmail.com>

Author: MachinisteWeb

src/v2/guide/components.md

@@ -1102,7 +1102,7 @@ Dans de grosses applications, nous avons parfois besoin de diviser la structure
 ``` js
 Vue.component('async-example', function (resolve, reject) {
   setTimeout(function () {
-    // Passer la définition du composant à la fonction de retour `resolve`
+    // Passer la définition du composant à la fonction de rappel `resolve`
     resolve({
       template: '<div>I am async!</div>'
     })

src/v2/guide/computed.md

@@ -112,7 +112,7 @@ Pourquoi avons-nous besoin de mettre en cache ? Imaginez que nous avons une prop
 
 ### Propriétés calculées vs observées
 
-Vue fournit une façon plus générique d'observer et de réagir aux changements de données sur une instance de Vue : **les propriétés watch**. Quand vous avez des données qu'il faut changer selon d'autres données, il est tentant d'abuser de `watch` (surtout si vous venez du monde d'AngularJS). Toutefois, il est souvent préférable d’utiliser une propriété calculée et non une fonction de retour impérative comme `watch`. Considérez cet exemple :
+Vue fournit une façon plus générique d'observer et de réagir aux changements de données sur une instance de Vue : **les propriétés watch**. Quand vous avez des données qu'il faut changer selon d'autres données, il est tentant d'abuser de `watch` (surtout si vous venez du monde d'AngularJS). Toutefois, il est souvent préférable d’utiliser une propriété calculée et non une fonction de rappel impérative comme `watch`. Considérez cet exemple :
 
 ``` html
 <div id="demo">{{ fullName }}</div>

src/v2/guide/instance.md

@@ -69,11 +69,11 @@ vm.$el === document.getElementById('example') // -> true
 
 // $watch est une méthode de l'instance
 vm.$watch('a', function (newVal, oldVal) {
-  // cette fonction de retour sera appelée quand `vm.a` changera
+  // cette fonction de rappel sera appelée quand `vm.a` changera
 })
 ```
 
-<p class="tip">N'utilisez pas les [fonctions fléchées](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fl%C3%A9ch%C3%A9es) sur une propriété ou fonction de retour d'une instance  (par exemple `vm.$watch('a', newVal => this.myMethod())`). Comme les fonctions fléchées sont liées au contexte parent, `this` ne sera pas l'instance de Vue comme vous pourriez vous y attendre et `this.myMethod` sera indéfini.</p>
+<p class="tip">N'utilisez pas les [fonctions fléchées](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fl%C3%A9ch%C3%A9es) sur une propriété ou fonction de rappel d'une instance  (par exemple `vm.$watch('a', newVal => this.myMethod())`). Comme les fonctions fléchées sont liées au contexte parent, `this` ne sera pas l'instance de Vue comme vous pourriez vous y attendre et `this.myMethod` sera indéfini.</p>
 
 Consultez [l'API](../api#Proprietes-dinstance) pour une liste complète des propriétés et méthodes d'une instance.
 

src/v2/guide/reactivity.md

@@ -75,7 +75,7 @@ Il y a des raisons techniques derrière cette restriction (ça élimine toute un
 
 ## File d'attente de mise à jour asynchrone
 
-Au cas où vous ne l'auriez pas encore remarqué, Vue effectue les mises à jour du DOM de façon **asynchrone**. Chaque fois qu'un changement de données est observé, cela ouvrira une file d'attente et mettra en mémoire toutes les modifications de données qui se sont produites dans la même boucle des événements. Si le même observateur est déclenché plusieurs fois, il ne sera ajouté qu'une seule fois dans la file d'attente. Cette suppression des doublons en mémoire est primordiale car elle évite des calculs et des manipulations du DOM inutiles. Puis, lors du prochain « tour » (tick) de la boucle des événements, Vue vide la file d'attente et effectue le travail (déjà dédoublonné). En interne, Vue essaie d'utiliser les fonctions natives `Promise.then` et `MutationObserver` pour la file d'attente asynchrone et se rabat sur `setTimeout(fn, 0)` si elles ne sont pas supportées. 
+Au cas où vous ne l'auriez pas encore remarqué, Vue effectue les mises à jour du DOM de façon **asynchrone**. Chaque fois qu'un changement de données est observé, cela ouvrira une file d'attente et mettra en mémoire toutes les modifications de données qui se sont produites dans la même boucle des événements. Si le même observateur est déclenché plusieurs fois, il ne sera ajouté qu'une seule fois dans la file d'attente. Cette suppression des doublons en mémoire est primordiale car elle évite des calculs et des manipulations du DOM inutiles. Puis, lors du prochain « tour » (tick) de la boucle des événements, Vue vide la file d'attente et effectue le travail (déjà dédoublonné). En interne, Vue essaie d'utiliser les fonctions natives `Promise.then` et `MutationObserver` pour la file d'attente asynchrone et se rabat sur `setTimeout(fn, 0)` si elles ne sont pas supportées.
 
 Par exemple, lorsque vous définissez `vm.someData = 'nouvelle valeur'`, le composant ne sera pas rendu de nouveau immédiatement. Il se mettra à jour au prochain « tour » (tick), lorsque la file d'attente sera vidée. La plupart du temps nous n'avons pas besoin de nous en soucier, mais cela peut être délicat lorsque vous voulez faire quelque chose qui dépend de l'état du DOM après sa mise à jour. Bien que Vue.js encourage généralement les développeurs à penser dans un mode « piloté par les données » (« data-driven ») en évitant de toucher le DOM directement, parfois il peut être nécessaire de se salir les mains. Afin d'attendre que Vue.js ait terminé la mise à jour du DOM après un changement de données, vous pouvez utiliser `Vue.nextTick (callback)` immédiatement après la modification des données. La fonction de retour sera appelée après que le DOM ait été mis à jour. Par exemple :
 
@@ -97,7 +97,7 @@ Vue.nextTick(function () {
 })
 ```
 
-Il y a aussi la méthode d'instance `vm.$nextTick()`, qui est particulièrement pratique à l'intérieur des composants, car elle n'a pas besoin de la variable globale de `Vue` et le contexte `this` de sa fonction de retour sera automatiquement lié à l'instance de Vue actuelle :
+Il y a aussi la méthode d'instance `vm.$nextTick()`, qui est particulièrement pratique à l'intérieur des composants, car elle n'a pas besoin de la variable globale de `Vue` et le contexte `this` de sa fonction de rappel sera automatiquement lié à l'instance de Vue actuelle :
 
 ``` js
 Vue.component('example', {

src/v2/guide/transitions.md

@@ -440,7 +440,7 @@ methods: {
 
 Ces hooks peuvent être utilisés en combinaison avec des transitions/animations CSS ou sur eux-mêmes.
 
-<p class="tip">Lors de l'utilisation de transitions uniquement JavaScript, **les fonctions de retour `done` sont obligatoires pour les hooks `enter` et `leave`**. Dans le cas contraire, elles seront appelées de façon synchrone et la transition se terminera immédiatement.</p>
+<p class="tip">Lors de l'utilisation de transitions uniquement JavaScript, **les fonctions de rappel `done` sont obligatoires pour les hooks `enter` et `leave`**. Dans le cas contraire, elles seront appelées de façon synchrone et la transition se terminera immédiatement.</p>
 
 <p class="tip">C'est aussi une bonne idée d'ajouter explicitement `v-bind:css="false"` pour les transitions uniquement JavaScript afin que Vue puisse ignorer la détection CSS. Cela empêche également les règles CSS d'interfèrer accidentellement avec la transition.</p>