From 662e8577a522a0840e18710fb38697734cd1edc8 Mon Sep 17 00:00:00 2001
From: Bruno Lesieur <bruno.lesieur@gmail.com>
Date: Mon, 5 Jun 2017 11:54:37 +0200
Subject: [PATCH 1/7] Starting render-function.md translation

Signed-off-by: Bruno Lesieur <bruno.lesieur@gmail.com>
---
 src/v2/guide/render-function.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/v2/guide/render-function.md b/src/v2/guide/render-function.md
index 08f6597315..56e74d0c66 100644
--- a/src/v2/guide/render-function.md
+++ b/src/v2/guide/render-function.md
@@ -1,12 +1,12 @@
 ---
-title: Render Functions (En)
+title: Fonctions de rendu
 type: guide
 order: 15
 ---
 
 ## Basics
 
-<p class="tip">**Cette page est en cours de traduction française. Revenez une autre fois pour lire une traduction achevée ou [participez à la traduction française ici](https://github.com/vuejs-fr/vuejs.org).**</p><p>Vue recommends using templates to build your HTML in the vast majority of cases. There are situations however, where you really need the full programmatic power of JavaScript. That's where you can use the **render function**, a closer-to-the-compiler alternative to templates.</p>
+Vue recommends using templates to build your HTML in the vast majority of cases. There are situations however, where you really need the full programmatic power of JavaScript. That's where you can use the **render function**, a closer-to-the-compiler alternative to templates.
 
 Let's dive into a simple example where a `render` function would be practical. Say you want to generate anchored headings:
 

From 2e6c9f5df0dc47b8000da1d0961d7dba2b7d8f69 Mon Sep 17 00:00:00 2001
From: Bruno Lesieur <bruno.lesieur@gmail.com>
Date: Mon, 5 Jun 2017 13:16:28 +0200
Subject: [PATCH 2/7] translated to 80%

Signed-off-by: Bruno Lesieur <bruno.lesieur@gmail.com>
---
 src/v2/guide/render-function.md | 194 ++++++++++++++++----------------
 1 file changed, 99 insertions(+), 95 deletions(-)

diff --git a/src/v2/guide/render-function.md b/src/v2/guide/render-function.md
index 56e74d0c66..4200ad94e1 100644
--- a/src/v2/guide/render-function.md
+++ b/src/v2/guide/render-function.md
@@ -4,27 +4,27 @@ type: guide
 order: 15
 ---
 
-## Basics
+## Les bases
 
-Vue recommends using templates to build your HTML in the vast majority of cases. There are situations however, where you really need the full programmatic power of JavaScript. That's where you can use the **render function**, a closer-to-the-compiler alternative to templates.
+Vue vous recommande l'utilisation de templates pour adresser votre HTML dans une grande majorité des cas. Il y a des situation ou cependant vous aurez réellement besoin du pouvoir de programmation du JavaScript. C'est la que vous pouvez utiliser les **fonctions de rendu**, une alternative aux templates plus proche du compilateur.
 
-Let's dive into a simple example where a `render` function would be practical. Say you want to generate anchored headings:
+Plongeons nous dans un simple exemple ou une fonction `render` serait plus pratique. Imaginons que nous souhaitons générer des ancres de titre :
 
 ``` html
 <h1>
   <a name="hello-world" href="#hello-world">
-    Hello world!
+    Hello world !
   </a>
 </h1>
 ```
 
-For the HTML above, you decide you want this component interface:
+Pour le HTML ci-dessus, vous décidez d'utiliser cette interface de composant :
 
 ``` html
 <anchored-heading :level="1">Hello world!</anchored-heading>
 ```
 
-When you get started with a component that just generates a heading based on the `level` prop, you quickly arrive at this:
+Quand vous commencez avec un composant se basant sur la prop `level` pour simplement générer des niveaux de titre, vous arrivez rapidement à cela :
 
 ``` html
 <script type="text/x-template" id="anchored-heading-template">
@@ -63,9 +63,9 @@ Vue.component('anchored-heading', {
 })
 ```
 
-That template doesn't feel great. It's not only verbose, but we're duplicating `<slot></slot>` for every heading level and will have to do the same when we add the anchor element. The whole thing is also wrapped in a useless `div` because components must contain exactly one root node.
+Ce template ne semble pas génial. Il n'est pas uniquement verbeux, il duplique `<slot></slot>` dans tous les niveaux de titre et nous allons devoir refaire la même chose pour chaque élément ancre. Le plus génant est également le fait d'entourer tous ses titres d'une `div` inutile car un composant doit contenir exactement une seul nœud racine.
 
-While templates work great for most components, it's clear that this isn't one of them. So let's try rewriting it with a `render` function:
+Alors que les templates marche bien pour la majorité des composants, il est clair que celui là n'est pas l'un d'entre eux. Aussi essayons de ré-écrire cela avec une fonction `render` :
 
 ``` js
 Vue.component('anchored-heading', {
@@ -84,29 +84,29 @@ Vue.component('anchored-heading', {
 })
 ```
 
-Much simpler! Sort of. The code is shorter, but also requires greater familiarity with Vue instance properties. In this case, you have to know that when you pass children without a `slot` attribute into a component, like the `Hello world!` inside of `anchored-heading`, those children are stored on the component instance at `$slots.default`. If you haven't already, **it's recommended to read through the [instance properties API](../api/#vm-slots) before diving into render functions.**
+C'est bien plus simple ! Le code est plus court mais demande une plus grande familiarité avec les propriétés d'une instance de Vue. Dans ce cas, vous devez savoir que lorsque vous passez des enfants dans attribut `slot` dans un composant, comme le `Hello world !` a l'intérieur de `anchored-heading`, ces enfants sont stockés dans l'instance du composant sous la propriété `$slots.default`. Si vous ne l'avez pas encore fait, **il est recommandé d'en lire plus sur les [propriétés d'instance de l'API](../api/#vm-slots) avant d'entrer plus en profondeur dans les fonctions de rendu.**
 
-## `createElement` Arguments
+## Les arguments de `createElement`
 
-The second thing you'll have to become familiar with is how to use template features in the `createElement` function. Here are the arguments that `createElement` accepts:
+La seconde chose a laquelle vous allez devoir vous familiariser est la manière d'utiliser les fonctionnalités de template avec la fonction `createElement`. Voici les arguments que la fonction `createElement` accepte :
 
 ``` js
 // @returns {VNode}
 createElement(
   // {String | Object | Function}
-  // An HTML tag name, component options, or function
-  // returning one of these. Required.
+  // Un nom de balise HTML, des options de composant, ou une fonction
+  // retournant l'un des deux. Requis.
   'div',
 
   // {Object}
-  // A data object corresponding to the attributes
-  // you would use in a template. Optional.
+  // Un objet de données correspondant aux attributs
+  // que vous souhaitez utiliser dans le template. Optionnel.
   {
-    // (see details in the next section below)
+    // (vu en détails dans la prochaine section)
   },
 
   // {String | Array}
-  // Children VNodes. Optional.
+  // Des VNodes enfants. Optionnel.
   [
     createElement('h1', 'hello world'),
     createElement(MyComponent, {
@@ -119,50 +119,50 @@ createElement(
 )
 ```
 
-### The Data Object In-Depth
+### L'objet de données dans le détail
 
-One thing to note: similar to how `v-bind:class` and `v-bind:style` have special treatment in templates, they have their own top-level fields in VNode data objects. This object also allows you to bind normal HTML attributes as well as DOM properties such as `innerHTML` (this would replace the `v-html` directive):
+Une chose est à noter : de la même manière que `v-bind:class` et `v-bind:style` ont un traitement spécial dans les templates, ils ont leurs propres champs dans les objets de données VNode. Cet objet vous permet également d'insérer des attributs HTML normaux comme le permet des fonctions comme `innerHTML` (cela remplace la directive `v-html`) :
 
 ``` js
 {
-  // Same API as `v-bind:class`
+  // Même API que `v-bind:class`
   'class': {
     foo: true,
     bar: false
   },
-  // Same API as `v-bind:style`
+  // Même API que `v-bind:style`
   style: {
     color: 'red',
     fontSize: '14px'
   },
-  // Normal HTML attributes
+  // Attributs HTML normaux
   attrs: {
     id: 'foo'
   },
-  // Component props
+  // Props des composants
   props: {
     myProp: 'bar'
   },
-  // DOM properties
+  // Propriétés du DOM
   domProps: {
     innerHTML: 'baz'
   },
-  // Event handlers are nested under "on", though
-  // modifiers such as in v-on:keyup.enter are not
-  // supported. You'll have to manually check the
-  // keyCode in the handler instead.
+  // La gestion d'évènement est regroupée sous `on` cependant
+  // les modificateurs comme `v-on:keyup.enter` ne sont pas
+  // supportés. Vous devez vérifier manuellement le code de touche
+  // dans le gertionnaire à la place.
   on: {
     click: this.clickHandler
   },
-  // For components only. Allows you to listen to
-  // native events, rather than events emitted from
-  // the component using vm.$emit.
+  // Pour les composants seulement. Vous permet d'écouter les
+  // évènements natifs, plutôt que ceux émis par
+  // le composant via `vm.$emit`.
   nativeOn: {
     click: this.nativeClickHandler
   },
-  // Custom directives. Note that the binding's
-  // oldValue cannot be set, as Vue keeps track
-  // of it for you.
+  // Directives personnalisées. Notons que la valeur liée
+  // `oldValue` ne peut être affectée, car Vue la conserve
+  // pour vous.
   directives: [
     {
       name: 'my-custom-directive',
@@ -174,23 +174,23 @@ One thing to note: similar to how `v-bind:class` and `v-bind:style` have special
       }
     }
   ],
-  // Scoped slots in the form of
+  // Slots internes sous la forme
   // { name: props => VNode | Array<VNode> }
   scopedSlots: {
     default: props => createElement('span', props.text)
   },
-  // The name of the slot, if this component is the
-  // child of another component
+  // Le nom du slot, si ce composant est
+  // l'enfant d'un autre composant
   slot: 'name-of-slot'
-  // Other special top-level properties
+  // Autres propriétés spéciales de premier niveau
   key: 'myKey',
   ref: 'myRef'
 }
 ```
 
-### Complete Example
+### Exemple complet
 
-With this knowledge, we can now finish the component we started:
+Avec toutes ces informations, nous pouvons finir le composant que nous avons commencé :
 
 ``` js
 var getChildrenTextContent = function (children) {
@@ -203,7 +203,7 @@ var getChildrenTextContent = function (children) {
 
 Vue.component('anchored-heading', {
   render: function (createElement) {
-    // create kebabCase id
+    // créer un identifiant avec la kebab-case
     var headingId = getChildrenTextContent(this.$slots.default)
       .toLowerCase()
       .replace(/\W+/g, '-')
@@ -230,23 +230,23 @@ Vue.component('anchored-heading', {
 })
 ```
 
-### Constraints
+### Contraintes
 
-#### VNodes Must Be Unique
+#### Les VNodes doivent être unique
 
-All VNodes in the component tree must be unique. That means the following render function is invalid:
+Tous les VNodes dans l'arbre des composants doivent être unique. Cela signifie que les fonctions suivantes sont invalides :
 
 ``` js
 render: function (createElement) {
   var myParagraphVNode = createElement('p', 'hi')
   return createElement('div', [
-    // Yikes - duplicate VNodes!
+    // Erf - VNodes dupliqués !
     myParagraphVNode, myParagraphVNode
   ])
 }
 ```
 
-If you really want to duplicate the same element/component many times, you can do so with a factory function. For example, the following render function is a perfectly valid way of rendering 20 identical paragraphs:
+Si vous souhaitez réellement dupliquer le même élément/composant plusieurs fois, vous voupez le faire avec une fonction de fabrique. Par exemple, la fonction de rendu suivante est parfaitement valide pour faire le rendu de 20 paragraphes identiques :
 
 ``` js
 render: function (createElement) {
@@ -258,11 +258,13 @@ render: function (createElement) {
 }
 ```
 
-## Replacing Template Features with Plain JavaScript
+## Remplacer les fonctionnalités de template avec du pure JavaScript
 
-### `v-if` and `v-for`
+### `v-if` et `v-for`
 
-Wherever something can be easily accomplished in plain JavaScript, Vue render functions do not provide a proprietary alternative. For example, in a template using `v-if` and `v-for`:
+
+
+Partout ou quelque chose peut être accomplie simplement en JavaScript, Les fonctions de rendu Vue ne fournissent pas d'alternatives personnelles. Par exemple, un template utilisant `v-if` et `v-for` :
 
 ``` html
 <ul v-if="items.length">
@@ -271,7 +273,7 @@ Wherever something can be easily accomplished in plain JavaScript, Vue render fu
 <p v-else>No items found.</p>
 ```
 
-This could be rewritten with JavaScript's `if`/`else` and `map` in a render function:
+Pourrait être ré-écrit avec les `if`/`else` et `map` du JavaScript dans une fonction de rendu
 
 ``` js
 render: function (createElement) {
@@ -287,7 +289,7 @@ render: function (createElement) {
 
 ### `v-model`
 
-There is no direct `v-model` counterpart in render functions - you will have to implement the logic yourself:
+Il n'y a pas d'équivalent à `v-model` dans les fonctions de rendu. Vous devez implémenter la logique vous-même :
 
 ``` js
 render: function (createElement) {
@@ -306,19 +308,19 @@ render: function (createElement) {
 }
 ```
 
-This is the cost of going lower-level, but it also gives you much more control over the interaction details compared to `v-model`.
+C'est le prix à payer pour travailler à bas niveau, mais cela vous donne un meilleur contrôle sur le détail des intéractions comparé à `v-model`.
 
-### Event & Key Modifiers
+### Modificateurs d'évènement et de code de touche
 
-For the `.capture` and `.once` event modifiers, Vue offers prefixes that can be used with `on`:
+Pour les modificateur d'évènement `.capture` et `.once`, Vue offre des préfixes pouvant être utilisé dans `on`:
 
-| Modifier(s) | Prefix |
+| Modificateur(s) | Préfixs |
 | ------ | ------ |
 | `.capture` | `!` |
 | `.once` | `~` |
-| `.capture.once` or<br>`.once.capture` | `~!` |
+| `.capture.once` ou<br>`.once.capture` | `~!` |
 
-For example:
+Par exemple :
 
 ```javascript
 on: {
@@ -328,31 +330,33 @@ on: {
 }
 ```
 
+Pour tous les autres modificateurs d'évènement et de code de touche, aucun préfixe propriétaire n'est nécessaire car il suffit d'utiliser des méthodes d'évènement dans le gestionnaire :
+
 For all other event and key modifiers, no proprietary prefix is necessary, because you can simply use event methods in the handler:
 
-| Modifier(s) | Equivalent in Handler |
+| Modificateur(s) | Équivalence dans le gestionnaire |
 | ------ | ------ |
 | `.stop` | `event.stopPropagation()` |
 | `.prevent` | `event.preventDefault()` |
 | `.self` | `if (event.target !== event.currentTarget) return` |
-| Keys:<br>`.enter`, `.13` | `if (event.keyCode !== 13) return` (change `13` to [another key code](http://keycode.info/) for other key modifiers) |
-| Modifiers Keys:<br>`.ctrl`, `.alt`, `.shift`, `.meta` | `if (!event.ctrlKey) return` (change `ctrlKey` to `altKey`, `shiftKey`, or `metaKey`, respectively) |
+| Touches :<br>`.enter`, `.13` | `if (event.keyCode !== 13) return` (changez `13` en un [autre code de touche](http://keycode.info/) pour les autres modificateurs de code de touche) |
+| Modificateurs de Clés :<br>`.ctrl`, `.alt`, `.shift`, `.meta` | `if (!event.ctrlKey) return` (changez respectivement `ctrlKey` par `altKey`, `shiftKey`, ou `metaKey`) |
 
-Here's an example with all of these modifiers used together:
+Voici un exemple avec tous ses modificateurs utilisés ensemble :
 
 ```javascript
 on: {
   keyup: function (event) {
-    // Abort if the element emitting the event is not
-    // the element the event is bound to
+    // Annuler si l'élément qui emet l'évènement n'est pas
+    // l'élément auquel l'évènement est lié
     if (event.target !== event.currentTarget) return
-    // Abort if the key that went up is not the enter
-    // key (13) and the shift key was not held down
-    // at the same time
+    // Annuler si la touche relachée n'est pas la touche
+    // entrer (13) et la clé `shift` n'est pas maintenue
+    // en même temps
     if (!event.shiftKey || event.keyCode !== 13) return
-    // Stop event propagation
+    // Arrêter la propagation d'évènement
     event.stopPropagation()
-    // Prevent the default keyup handler for this element
+    // Éviter la gestion par défaut de cet évènement pour cet élément
     event.preventDefault()
     // ...
   }
@@ -361,20 +365,20 @@ on: {
 
 ### Slots
 
-You can access static slot contents as Arrays of VNodes from [`this.$slots`](../api/#vm-slots):
+Vous pouvez accéder aux contenus statique des slots en tant que tableaux de VNodes depuis [`this.$slots`](../api/#vm-slots) :
 
 ``` js
 render: function (createElement) {
-  // <div><slot></slot></div>
+  // `<div><slot></slot></div>`
   return createElement('div', this.$slots.default)
 }
 ```
 
-And access scoped slots as functions that return VNodes from [`this.$scopedSlots`](../api/#vm-scopedSlots):
+Et accéer aux slots internes en tant que fonctions qui retourne des VNodes depuis [`this.$scopedSlots`](../api/#vm-scopedSlots) :
 
 ``` js
 render: function (createElement) {
-  // <div><slot :text="msg"></slot></div>
+  // `<div><slot :text="msg"></slot></div>`
   return createElement('div', [
     this.$scopedSlots.default({
       text: this.msg
@@ -383,13 +387,13 @@ render: function (createElement) {
 }
 ```
 
-To pass scoped slots to a child component using render functions, use the `scopedSlots` field in VNode data:
+Pour passer des slots internes à un composant enfant utilisant des fonctions de rendu, utilisez la propriété `scopedSlots` dans les données du VNode :
 
 ``` js
 render (createElement) {
   return createElement('div', [
     createElement('child', {
-      // pass scopedSlots in the data object
+      // passer `scopedSlots` dans l'objet de données
       // in the form of { name: props => VNode | Array<VNode> }
       scopedSlots: {
         default: function (props) {
@@ -403,7 +407,7 @@ render (createElement) {
 
 ## JSX
 
-If you're writing a lot of `render` functions, it might feel painful to write something like this:
+Si vous écrivez beaucoup de functions de rendu, cela pourra vous sembler fatiguant d'écrire des choses comme ça :
 
 ``` js
 createElement(
@@ -418,7 +422,7 @@ createElement(
 )
 ```
 
-Especially when the template version is so simple in comparison:
+Et d'autant plus quand la version template est vraiment simple en comparaison :
 
 ``` html
 <anchored-heading :level="1">
@@ -426,7 +430,7 @@ Especially when the template version is so simple in comparison:
 </anchored-heading>
 ```
 
-That's why there's a [Babel plugin](https://github.com/vuejs/babel-plugin-transform-vue-jsx) to use JSX with Vue, getting us back to a syntax that's closer to templates:
+C'est pour quoi il y a un [plugin Babel](https://github.com/vuejs/babel-plugin-transform-vue-jsx) pour utiliser JSX avec Vue, nous permettant l'utilisation d'une syntaxe plus proche de celle des templates :
 
 ``` js
 import AnchoredHeading from './AnchoredHeading.vue'
@@ -443,44 +447,44 @@ new Vue({
 })
 ```
 
-<p class="tip">Aliasing `createElement` to `h` is a common convention you'll see in the Vue ecosystem and is actually required for JSX. If `h` is not available in the scope, your app will throw an error.</p>
+<p class="tip">Utiliser `h` comme alias de `createElement` est une convention courante que vous verrez dans l'écosystème Vue qui est de plus requis pour JSX. Si `h` n'est pas disponible dans votre portée courante, votre application va lever une erreur.</p>
 
-For more on how JSX maps to JavaScript, see the [usage docs](https://github.com/vuejs/babel-plugin-transform-vue-jsx#usage).
+Pour plus d'information sur comment utiliser JSX dans du JavaScript, référez-vous à la [documentation d'utilisation](https://github.com/vuejs/babel-plugin-transform-vue-jsx#usage).
 
-## Functional Components
+## Composants fonctionnels
 
-The anchored heading component we created earlier is relatively simple. It doesn't manage any state, watch any state passed to it, and it has no lifecycle methods. Really, it's just a function with some props.
+Les titres avec ancres que nous avons créé plus tôt était relativement simple. Il ne gère aucun état, observateur ou état passé du dessus, et il n'a aucune méthode de cycle de vie. Non, ce n'est qu'une simple fonction avec quelque props.
 
-In cases like this, we can mark components as `functional`, which means that they're stateless (no `data`) and instanceless (no `this` context). A **functional component** looks like this:
+Dans dès cas comme ça, nous pouvons marquer les composants comme `functonal`, ce qui signifie qu'ils sont sans état (« stateless » c.-à-d. sans `data`) et sans instance (« instanceless » c.-à-d. sans contexte `this`). Un composant fonctionnel ressemble à ça :
 
 ``` js
 Vue.component('my-component', {
   functional: true,
-  // To compensate for the lack of an instance,
-  // we are now provided a 2nd context argument.
+  // Pour compenser le manque d'instance,
+  // nous pouvons maintenant fournir en second argument un contexte.
   render: function (createElement, context) {
     // ...
   },
-  // Props are optional
+  // Les props sont optionnelles
   props: {
     // ...
   }
 })
 ```
 
-> Note: in versions <=2.3.0, the `props` option is required if you wish to accept props in a functional component. In 2.3.0+ you can omit the `props` option and all attributes found on the component node will be implicitly extracted as props.
+> Note : dans les versions <= 2.3.0, l'option `props` est requise si vous souhaitez accepter des props dans un composant fonctionnel. Dans les versions 2.3.0+ vous pouvez ommettre l'option `props` et tous les attributs trouvés dans le nœud composant seront implicitement extrait comme des props.
 
-Everything the component needs is passed through `context`, which is an object containing:
+Tout ce dont le composant a besoin est passé dans l'objet `context`, qui est un objet contenant :
 
-- `props`: An object of the provided props
-- `children`: An array of the VNode children
-- `slots`: A function returning a slots object
-- `data`: The entire data object passed to the component
-- `parent`: A reference to the parent component
-- `listeners`: (2.3.0+) An object containing parent-registered event listeners. This is simply an alias to `data.on`
-- `injections`: (2.3.0+) if using the [`inject`](../api/#provide-inject) option, this will contain resolved injections.
+- `props`: un objet avec les props fournies,
+- `children`: un tableau de VNode enfant,
+- `slots`: une fonction retournant un objet de slots,
+- `data`: l'objet de données (`data`) complet passé au composant,
+- `parent`: une référence au composant parent,
+- `listeners`: (2.3.0+) un objet contenant les écouteurs d'évènement enregistré du parent. C'est un simple alias de `data.on`,
+- `injections`: (2.3.0+) si vous utilisez l'option [`inject`](../api/#provide-inject), cela va contenir les injections résolues.
 
-After adding `functional: true`, updating the render function of our anchored heading component would simply require adding the `context` argument, updating `this.$slots.default` to `context.children`, then updating `this.level` to `context.props.level`.
+Après avoir ajouté `functional: true`, mettre a jour la fonction de rendu de votre composant de titres avec ancres va seulement demander l'utilisation de l'argument `context`, la mise à jour de `this.$slots.default` pour `context.children`, puis la mise à jour de `this.level` pour `context.props.level`.
 
 Since functional components are just functions, they're much cheaper to render. However, this also mean that functional components don't show up in VueJS Chrome dev tools component tree.
 

From 25f0017f2ae55d3b155e56e576230e535427f64b Mon Sep 17 00:00:00 2001
From: Bruno Lesieur <bruno.lesieur@gmail.com>
Date: Mon, 5 Jun 2017 16:01:11 +0200
Subject: [PATCH 3/7] Update website

Signed-off-by: Bruno Lesieur <bruno.lesieur@gmail.com>
---
 src/v2/guide/render-function.md | 62 ++++++++++++++++-----------------
 1 file changed, 30 insertions(+), 32 deletions(-)

diff --git a/src/v2/guide/render-function.md b/src/v2/guide/render-function.md
index 4200ad94e1..f6c57f11f5 100644
--- a/src/v2/guide/render-function.md
+++ b/src/v2/guide/render-function.md
@@ -63,7 +63,7 @@ Vue.component('anchored-heading', {
 })
 ```
 
-Ce template ne semble pas génial. Il n'est pas uniquement verbeux, il duplique `<slot></slot>` dans tous les niveaux de titre et nous allons devoir refaire la même chose pour chaque élément ancre. Le plus génant est également le fait d'entourer tous ses titres d'une `div` inutile car un composant doit contenir exactement une seul nœud racine.
+Ce template ne semble pas génial. Il n'est pas uniquement verbeux, il duplique `<slot></slot>` dans tous les niveaux de titre et nous allons devoir refaire la même chose pour chaque élément ancre. Le plus gênant est également le fait d'entourer tous ses titres d'une `div` inutile car un composant doit contenir exactement une seul nœud racine.
 
 Alors que les templates marche bien pour la majorité des composants, il est clair que celui là n'est pas l'un d'entre eux. Aussi essayons de ré-écrire cela avec une fonction `render` :
 
@@ -150,7 +150,7 @@ Une chose est à noter : de la même manière que `v-bind:class` et `v-bind:styl
   // La gestion d'évènement est regroupée sous `on` cependant
   // les modificateurs comme `v-on:keyup.enter` ne sont pas
   // supportés. Vous devez vérifier manuellement le code de touche
-  // dans le gertionnaire à la place.
+  // dans le gestionnaire à la place.
   on: {
     click: this.clickHandler
   },
@@ -246,7 +246,7 @@ render: function (createElement) {
 }
 ```
 
-Si vous souhaitez réellement dupliquer le même élément/composant plusieurs fois, vous voupez le faire avec une fonction de fabrique. Par exemple, la fonction de rendu suivante est parfaitement valide pour faire le rendu de 20 paragraphes identiques :
+Si vous souhaitez réellement dupliquer le même élément/composant plusieurs fois, vous pouvez le faire avec une fonction de fabrique. Par exemple, la fonction de rendu suivante est parfaitement valide pour faire le rendu de 20 paragraphes identiques :
 
 ``` js
 render: function (createElement) {
@@ -270,7 +270,7 @@ Partout ou quelque chose peut être accomplie simplement en JavaScript, Les fonc
 <ul v-if="items.length">
   <li v-for="item in items">{{ item.name }}</li>
 </ul>
-<p v-else>No items found.</p>
+<p v-else>Aucun élément trouvé.</p>
 ```
 
 Pourrait être ré-écrit avec les `if`/`else` et `map` du JavaScript dans une fonction de rendu
@@ -282,7 +282,7 @@ render: function (createElement) {
       return createElement('li', item.name)
     }))
   } else {
-    return createElement('p', 'No items found.')
+    return createElement('p', 'Aucun élément trouvé.')
   }
 }
 ```
@@ -308,7 +308,7 @@ render: function (createElement) {
 }
 ```
 
-C'est le prix à payer pour travailler à bas niveau, mais cela vous donne un meilleur contrôle sur le détail des intéractions comparé à `v-model`.
+C'est le prix à payer pour travailler à bas niveau, mais cela vous donne un meilleur contrôle sur le détail des interactions comparé à `v-model`.
 
 ### Modificateurs d'évènement et de code de touche
 
@@ -332,8 +332,6 @@ on: {
 
 Pour tous les autres modificateurs d'évènement et de code de touche, aucun préfixe propriétaire n'est nécessaire car il suffit d'utiliser des méthodes d'évènement dans le gestionnaire :
 
-For all other event and key modifiers, no proprietary prefix is necessary, because you can simply use event methods in the handler:
-
 | Modificateur(s) | Équivalence dans le gestionnaire |
 | ------ | ------ |
 | `.stop` | `event.stopPropagation()` |
@@ -347,10 +345,10 @@ Voici un exemple avec tous ses modificateurs utilisés ensemble :
 ```javascript
 on: {
   keyup: function (event) {
-    // Annuler si l'élément qui emet l'évènement n'est pas
+    // Annuler si l'élément qui émet l'évènement n'est pas
     // l'élément auquel l'évènement est lié
     if (event.target !== event.currentTarget) return
-    // Annuler si la touche relachée n'est pas la touche
+    // Annuler si la touche relâchée n'est pas la touche
     // entrer (13) et la clé `shift` n'est pas maintenue
     // en même temps
     if (!event.shiftKey || event.keyCode !== 13) return
@@ -407,7 +405,7 @@ render (createElement) {
 
 ## JSX
 
-Si vous écrivez beaucoup de functions de rendu, cela pourra vous sembler fatiguant d'écrire des choses comme ça :
+Si vous écrivez beaucoup de fonctions de rendu, cela pourra vous sembler fatiguant d'écrire des choses comme ça :
 
 ``` js
 createElement(
@@ -426,7 +424,7 @@ Et d'autant plus quand la version template est vraiment simple en comparaison :
 
 ``` html
 <anchored-heading :level="1">
-  <span>Hello</span> world!
+  <span>Hello</span> world !
 </anchored-heading>
 ```
 
@@ -440,7 +438,7 @@ new Vue({
   render (h) {
     return (
       <AnchoredHeading level={1}>
-        <span>Hello</span> world!
+        <span>Hello</span> world !
       </AnchoredHeading>
     )
   }
@@ -455,7 +453,7 @@ Pour plus d'information sur comment utiliser JSX dans du JavaScript, référez-v
 
 Les titres avec ancres que nous avons créé plus tôt était relativement simple. Il ne gère aucun état, observateur ou état passé du dessus, et il n'a aucune méthode de cycle de vie. Non, ce n'est qu'une simple fonction avec quelque props.
 
-Dans dès cas comme ça, nous pouvons marquer les composants comme `functonal`, ce qui signifie qu'ils sont sans état (« stateless » c.-à-d. sans `data`) et sans instance (« instanceless » c.-à-d. sans contexte `this`). Un composant fonctionnel ressemble à ça :
+Dans dès cas comme ça, nous pouvons marquer les composants comme `functional`, ce qui signifie qu'ils sont sans état (« stateless » c.-à-d. sans `data`) et sans instance (« instanceless » c.-à-d. sans contexte `this`). Un composant fonctionnel ressemble à ça :
 
 ``` js
 Vue.component('my-component', {
@@ -472,7 +470,7 @@ Vue.component('my-component', {
 })
 ```
 
-> Note : dans les versions <= 2.3.0, l'option `props` est requise si vous souhaitez accepter des props dans un composant fonctionnel. Dans les versions 2.3.0+ vous pouvez ommettre l'option `props` et tous les attributs trouvés dans le nœud composant seront implicitement extrait comme des props.
+> Note : dans les versions <= 2.3.0, l'option `props` est requise si vous souhaitez accepter des props dans un composant fonctionnel. Dans les versions 2.3.0+ vous pouvez omettre l'option `props` et tous les attributs trouvés dans le nœud composant seront implicitement extrait comme des props.
 
 Tout ce dont le composant a besoin est passé dans l'objet `context`, qui est un objet contenant :
 
@@ -486,14 +484,14 @@ Tout ce dont le composant a besoin est passé dans l'objet `context`, qui est un
 
 Après avoir ajouté `functional: true`, mettre a jour la fonction de rendu de votre composant de titres avec ancres va seulement demander l'utilisation de l'argument `context`, la mise à jour de `this.$slots.default` pour `context.children`, puis la mise à jour de `this.level` pour `context.props.level`.
 
-Since functional components are just functions, they're much cheaper to render. However, this also mean that functional components don't show up in VueJS Chrome dev tools component tree.
+Puisque les composants fonctionnels ne sont que des fonctions, leur rendu est plus rapide. Cependant, cela signifie également que les composants fonctionnels n'apparaissent pas dans l'arbre des composants de l'outil de développement Vue.js de Chrome.
 
-They're also very useful as wrapper components.  For example, when you need to:
+Ils sont également très utile en tant que composant encadrant. Par exemple, quand vous avez besoin de :
 
-- Programmatically choose one of several other components to delegate to
-- Manipulate children, props, or data before passing them on to a child component
+- Programmatiquement choisir un composant parmi plusieurs autres composant pour de la délégation ou
+- Manipuler les enfants, props, ou données avant de les passer au composant enfant.
 
-Here's an example of a `smart-list` component that delegates to more specific components, depending on the props passed to it:
+Voici un exemple d'un composant `smart-list` qui délègue à des composants plus spécifiques en fonction des props qui lui sont passées :
 
 ``` js
 var EmptyList = { /* ... */ }
@@ -530,37 +528,37 @@ Vue.component('smart-list', {
 })
 ```
 
-### `slots()` vs `children`
+### `slots()` vs. `children`
 
-You may wonder why we need both `slots()` and `children`. Wouldn't `slots().default` be the same as `children`? In some cases, yes - but what if you have a functional component with the following children?
+Vous vous demandez peut-être l'utilité d'avoir `slot()` et `children` en même temps. `slots().default` n'est pas la même chose que `children` ? Dans la majorité des cas, oui. Mais que faire si vous avez le composant fonctionnel suivant avec les enfants suivants ?
 
 ``` html
 <my-functional-component>
   <p slot="foo">
-    first
+    premier
   </p>
   <p>second</p>
 </my-functional-component>
 ```
 
-For this component, `children` will give you both paragraphs, `slots().default` will give you only the second, and `slots().foo` will give you only the first. Having both `children` and `slots()` therefore allows you to choose whether this component knows about a slot system or perhaps delegates that responsibility to another component by simply passing along `children`.
+Pour ce composant `children` va vous donner les deux paragraphes, `slots().default` ne vous donnera que le second, et `slots().foo` ne vous donnera que le premier. Avoir le choix entre `children` et `slots()` donc a vous de choisir ce que le composant sait à propos du système de slot ou si vous déléguez peut-être la responsabilité à un autre composant en passant simplement `children`.
 
-## Template Compilation
+## Compilation de template
 
-You may be interested to know that Vue's templates actually compile to render functions. This is an implementation detail you usually don't need to know about, but if you'd like to see how specific template features are compiled, you may find it interesting. Below is a little demo using `Vue.compile` to live-compile a template string:
+Vous serez peut-être intéresser de savoir que les templates Vue sont en fait compilé en fonctions de rendu. C'est un détail d'implémentation dont vous avez en général pas à vous soucier, mais si vous souhaiter savoir comment un template spécifique est compilé, vous pourrez trouver cela intéressant. Vous trouverez ci-dessous une petite démo utilisant `Vue.compile` pour voir en live le rendu d'une chaîne de template :
 
 {% raw %}
 <div id="vue-compile-demo" class="demo">
   <textarea v-model="templateText" rows="10"></textarea>
   <div v-if="typeof result === 'object'">
-    <label>render:</label>
+    <label>rendu :</label>
     <pre><code>{{ result.render }}</code></pre>
-    <label>staticRenderFns:</label>
+    <label>staticRenderFns :</label>
     <pre v-for="(fn, index) in result.staticRenderFns"><code>_m({{ index }}): {{ fn }}</code></pre>
     <pre v-if="!result.staticRenderFns.length"><code>{{ result.staticRenderFns }}</code></pre>
   </div>
   <div v-else>
-    <label>Compilation Error:</label>
+    <label>Erreur de compilation :</label>
     <pre><code>{{ result }}</code></pre>
   </div>
 </div>
@@ -571,13 +569,13 @@ new Vue({
     templateText: '\
 <div>\n\
   <header>\n\
-    <h1>I\'m a template!</h1>\n\
+    <h1>Je suis un template !</h1>\n\
   </header>\n\
   <p v-if="message">\n\
     {{ message }}\n\
   </p>\n\
   <p v-else>\n\
-    No message.\n\
+    Pas de message.\n\
   </p>\n\
 </div>\
     ',
@@ -585,7 +583,7 @@ new Vue({
   computed: {
     result: function () {
       if (!this.templateText) {
-        return 'Enter a valid template above'
+        return 'Entrez ci-dessous un template valide'
       }
       try {
         var result = Vue.compile(this.templateText.replace(/\s{2,}/g, ''))

From b8e48aeba8f32d36efee5b6fe6b66d36d5ff3f6b Mon Sep 17 00:00:00 2001
From: Bruno Lesieur <bruno.lesieur@gmail.com>
Date: Mon, 5 Jun 2017 17:43:22 +0200
Subject: [PATCH 4/7] =?UTF-8?q?R=C3=A9-aligner=20le=20nombre=20de=20ligne?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Bruno Lesieur <bruno.lesieur@gmail.com>
---
 src/v2/guide/render-function.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/v2/guide/render-function.md b/src/v2/guide/render-function.md
index f6c57f11f5..0ebce2b5cc 100644
--- a/src/v2/guide/render-function.md
+++ b/src/v2/guide/render-function.md
@@ -262,8 +262,6 @@ render: function (createElement) {
 
 ### `v-if` et `v-for`
 
-
-
 Partout ou quelque chose peut être accomplie simplement en JavaScript, Les fonctions de rendu Vue ne fournissent pas d'alternatives personnelles. Par exemple, un template utilisant `v-if` et `v-for` :
 
 ``` html

From fdba231628c45eb97a3ad79a2921b71a971987a3 Mon Sep 17 00:00:00 2001
From: Bruno Lesieur <bruno.lesieur@gmail.com>
Date: Mon, 12 Jun 2017 16:47:18 +0200
Subject: [PATCH 5/7] =?UTF-8?q?Modifications=20suite=20=C3=A0=20la=20revie?=
 =?UTF-8?q?w=20de=20sylvain?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Bruno Lesieur <bruno.lesieur@gmail.com>
---
 src/v2/guide/render-function.md | 72 ++++++++++++++++-----------------
 1 file changed, 36 insertions(+), 36 deletions(-)

diff --git a/src/v2/guide/render-function.md b/src/v2/guide/render-function.md
index 0ebce2b5cc..3d37db36bf 100644
--- a/src/v2/guide/render-function.md
+++ b/src/v2/guide/render-function.md
@@ -6,9 +6,9 @@ order: 15
 
 ## Les bases
 
-Vue vous recommande l'utilisation de templates pour adresser votre HTML dans une grande majorité des cas. Il y a des situation ou cependant vous aurez réellement besoin du pouvoir de programmation du JavaScript. C'est la que vous pouvez utiliser les **fonctions de rendu**, une alternative aux templates plus proche du compilateur.
+Vue vous recommande l'utilisation de templates pour construire votre HTML dans la grande majorité des cas. Il y a cependant des situation ou vous aurez réellement besoin de toute la puissance programmatique de JavaScript. C'est là que vous pouvez utiliser les **fonctions de rendu**, une alternative aux templates qui est plus proche du compilateur.
 
-Plongeons nous dans un simple exemple ou une fonction `render` serait plus pratique. Imaginons que nous souhaitons générer des ancres de titre :
+Voyons un simple exemple où une fonction `render` serait plus pratique. Imaginons que nous souhaitons générer des titres avec une ancre :
 
 ``` html
 <h1>
@@ -63,9 +63,9 @@ Vue.component('anchored-heading', {
 })
 ```
 
-Ce template ne semble pas génial. Il n'est pas uniquement verbeux, il duplique `<slot></slot>` dans tous les niveaux de titre et nous allons devoir refaire la même chose pour chaque élément ancre. Le plus gênant est également le fait d'entourer tous ses titres d'une `div` inutile car un composant doit contenir exactement une seul nœud racine.
+Ce template ne semble pas génial. Il n'est pas uniquement verbeux, il duplique `<slot></slot>` dans tous les niveaux de titre et nous allons devoir refaire la même chose quand nous ajoutons l'élément ancre. Tout cela est également encapsulé dans une `div` inutile car un composant doit contenir exactement un seul nœud racine.
 
-Alors que les templates marche bien pour la majorité des composants, il est clair que celui là n'est pas l'un d'entre eux. Aussi essayons de ré-écrire cela avec une fonction `render` :
+Alors que les templates fonctionnent bien pour la plupart des composants, il est clair que celui-là n'est pas l'un d'entre eux. Aussi essayons de le réécrire avec une fonction `render` :
 
 ``` js
 Vue.component('anchored-heading', {
@@ -84,11 +84,11 @@ Vue.component('anchored-heading', {
 })
 ```
 
-C'est bien plus simple ! Le code est plus court mais demande une plus grande familiarité avec les propriétés d'une instance de Vue. Dans ce cas, vous devez savoir que lorsque vous passez des enfants dans attribut `slot` dans un composant, comme le `Hello world !` a l'intérieur de `anchored-heading`, ces enfants sont stockés dans l'instance du composant sous la propriété `$slots.default`. Si vous ne l'avez pas encore fait, **il est recommandé d'en lire plus sur les [propriétés d'instance de l'API](../api/#vm-slots) avant d'entrer plus en profondeur dans les fonctions de rendu.**
+C'est bien plus simple ! Le code est plus court mais demande une plus grande familiarité avec les propriétés d'une instance de Vue. Dans ce cas, vous devez savoir que lorsque vous passez des enfants dans attribut `slot` dans un composant, comme le `Hello world !` à l'intérieur de `anchored-heading`, ces enfants sont stockés dans l'instance du composant via la propriété `$slots.default`. Si vous ne l'avez pas encore fait, **il est recommandé d'en lire plus sur les [propriétés d'instance de l'API](../api/#vm-slots) avant d'entrer plus en profondeur dans les fonctions de rendu.**
 
 ## Les arguments de `createElement`
 
-La seconde chose a laquelle vous allez devoir vous familiariser est la manière d'utiliser les fonctionnalités de template avec la fonction `createElement`. Voici les arguments que la fonction `createElement` accepte :
+La seconde chose à laquelle vous allez devoir vous familiariser est la manière d'utiliser les fonctionnalités des templates avec la fonction `createElement`. Voici les arguments que la fonction `createElement` accepte :
 
 ``` js
 // @returns {VNode}
@@ -121,7 +121,7 @@ createElement(
 
 ### L'objet de données dans le détail
 
-Une chose est à noter : de la même manière que `v-bind:class` et `v-bind:style` ont un traitement spécial dans les templates, ils ont leurs propres champs dans les objets de données VNode. Cet objet vous permet également d'insérer des attributs HTML normaux comme le permet des fonctions comme `innerHTML` (cela remplace la directive `v-html`) :
+Une chose est à noter : de la même manière que `v-bind:class` et `v-bind:style` ont un traitement spécial dans les templates, ils ont leurs propres champs dans les objets de données VNode. Cet objet vous permet également d'insérer des attributs HTML normaux ainsi que des propriétés du DOM comme `innerHTML` (cela remplace la directive `v-html`) :
 
 ``` js
 {
@@ -160,8 +160,8 @@ Une chose est à noter : de la même manière que `v-bind:class` et `v-bind:styl
   nativeOn: {
     click: this.nativeClickHandler
   },
-  // Directives personnalisées. Notons que la valeur liée
-  // `oldValue` ne peut être affectée, car Vue la conserve
+  // Directives personnalisées. Notez que la valeur `oldValue`
+  // de la liaison ne peut pas être affectée, car Vue la conserve
   // pour vous.
   directives: [
     {
@@ -232,9 +232,9 @@ Vue.component('anchored-heading', {
 
 ### Contraintes
 
-#### Les VNodes doivent être unique
+#### Les VNodes doivent être uniques
 
-Tous les VNodes dans l'arbre des composants doivent être unique. Cela signifie que les fonctions suivantes sont invalides :
+Tous les VNodes dans l'arbre des composants doivent être uniques. Cela signifie que les fonctions suivantes sont invalides :
 
 ``` js
 render: function (createElement) {
@@ -246,7 +246,7 @@ render: function (createElement) {
 }
 ```
 
-Si vous souhaitez réellement dupliquer le même élément/composant plusieurs fois, vous pouvez le faire avec une fonction de fabrique. Par exemple, la fonction de rendu suivante est parfaitement valide pour faire le rendu de 20 paragraphes identiques :
+Si vous souhaitez réellement dupliquer le même élément/composant plusieurs fois, vous pouvez le faire avec une fonction fabrique. Par exemple, la fonction de rendu suivante est parfaitement valide pour faire le rendu de 20 paragraphes identiques :
 
 ``` js
 render: function (createElement) {
@@ -258,11 +258,11 @@ render: function (createElement) {
 }
 ```
 
-## Remplacer les fonctionnalités de template avec du pure JavaScript
+## Remplacer les fonctionnalités de template en pur JavaScript
 
 ### `v-if` et `v-for`
 
-Partout ou quelque chose peut être accomplie simplement en JavaScript, Les fonctions de rendu Vue ne fournissent pas d'alternatives personnelles. Par exemple, un template utilisant `v-if` et `v-for` :
+Partout où quelque chose peut être accompli simplement en JavaScript, les fonctions de rendu de Vue ne fournissent pas d'alternative propriétaire. Par exemple, un template utilisant `v-if` et `v-for` :
 
 ``` html
 <ul v-if="items.length">
@@ -271,7 +271,7 @@ Partout ou quelque chose peut être accomplie simplement en JavaScript, Les fonc
 <p v-else>Aucun élément trouvé.</p>
 ```
 
-Pourrait être ré-écrit avec les `if`/`else` et `map` du JavaScript dans une fonction de rendu
+Cela pourrait être réécrit avec les `if`/`else` et `map` du JavaScript dans une fonction de rendu
 
 ``` js
 render: function (createElement) {
@@ -310,9 +310,9 @@ C'est le prix à payer pour travailler à bas niveau, mais cela vous donne un me
 
 ### Modificateurs d'évènement et de code de touche
 
-Pour les modificateur d'évènement `.capture` et `.once`, Vue offre des préfixes pouvant être utilisé dans `on`:
+Pour les modificateurs d'évènement `.capture` et `.once`, Vue offre des préfixes pouvant être utilisé dans `on`:
 
-| Modificateur(s) | Préfixs |
+| Modificateur(s) | Préfixes |
 | ------ | ------ |
 | `.capture` | `!` |
 | `.once` | `~` |
@@ -338,7 +338,7 @@ Pour tous les autres modificateurs d'évènement et de code de touche, aucun pr
 | Touches :<br>`.enter`, `.13` | `if (event.keyCode !== 13) return` (changez `13` en un [autre code de touche](http://keycode.info/) pour les autres modificateurs de code de touche) |
 | Modificateurs de Clés :<br>`.ctrl`, `.alt`, `.shift`, `.meta` | `if (!event.ctrlKey) return` (changez respectivement `ctrlKey` par `altKey`, `shiftKey`, ou `metaKey`) |
 
-Voici un exemple avec tous ses modificateurs utilisés ensemble :
+Voici un exemple avec tous ces modificateurs utilisés ensemble :
 
 ```javascript
 on: {
@@ -347,7 +347,7 @@ on: {
     // l'élément auquel l'évènement est lié
     if (event.target !== event.currentTarget) return
     // Annuler si la touche relâchée n'est pas la touche
-    // entrer (13) et la clé `shift` n'est pas maintenue
+    // Entrée (13) et si la touche `shift` n'est pas maintenue
     // en même temps
     if (!event.shiftKey || event.keyCode !== 13) return
     // Arrêter la propagation d'évènement
@@ -361,7 +361,7 @@ on: {
 
 ### Slots
 
-Vous pouvez accéder aux contenus statique des slots en tant que tableaux de VNodes depuis [`this.$slots`](../api/#vm-slots) :
+Vous pouvez accéder aux contenus des slots statiques en tant que tableaux de VNodes depuis [`this.$slots`](../api/#vm-slots) :
 
 ``` js
 render: function (createElement) {
@@ -370,7 +370,7 @@ render: function (createElement) {
 }
 ```
 
-Et accéer aux slots internes en tant que fonctions qui retourne des VNodes depuis [`this.$scopedSlots`](../api/#vm-scopedSlots) :
+Et accéder aux slots de portée en tant que fonctions qui retournent des VNodes via [`this.$scopedSlots`](../api/#vm-scopedSlots) :
 
 ``` js
 render: function (createElement) {
@@ -383,7 +383,7 @@ render: function (createElement) {
 }
 ```
 
-Pour passer des slots internes à un composant enfant utilisant des fonctions de rendu, utilisez la propriété `scopedSlots` dans les données du VNode :
+Pour passer des slots internes à un composant enfant en utilisant des fonctions de rendu, utilisez la propriété `scopedSlots` dans les données du VNode :
 
 ``` js
 render (createElement) {
@@ -426,7 +426,7 @@ Et d'autant plus quand la version template est vraiment simple en comparaison :
 </anchored-heading>
 ```
 
-C'est pour quoi il y a un [plugin Babel](https://github.com/vuejs/babel-plugin-transform-vue-jsx) pour utiliser JSX avec Vue, nous permettant l'utilisation d'une syntaxe plus proche de celle des templates :
+C'est pourquoi il y a un [plugin Babel](https://github.com/vuejs/babel-plugin-transform-vue-jsx) pour utiliser JSX avec Vue, nous permettant l'utilisation d'une syntaxe plus proche de celle des templates :
 
 ``` js
 import AnchoredHeading from './AnchoredHeading.vue'
@@ -443,15 +443,15 @@ new Vue({
 })
 ```
 
-<p class="tip">Utiliser `h` comme alias de `createElement` est une convention courante que vous verrez dans l'écosystème Vue qui est de plus requis pour JSX. Si `h` n'est pas disponible dans votre portée courante, votre application va lever une erreur.</p>
+<p class="tip">Utiliser `h` comme alias de `createElement` est une convention courante que vous verrez dans l'écosystème Vue et qui est en faite requise pour JSX. Si `h` n'est pas disponible dans votre portée courante, votre application va lever une erreur.</p>
 
-Pour plus d'information sur comment utiliser JSX dans du JavaScript, référez-vous à la [documentation d'utilisation](https://github.com/vuejs/babel-plugin-transform-vue-jsx#usage).
+Pour plus d'informations sur comment utiliser JSX dans du JavaScript, référez-vous à la [documentation d'utilisation](https://github.com/vuejs/babel-plugin-transform-vue-jsx#usage).
 
 ## Composants fonctionnels
 
-Les titres avec ancres que nous avons créé plus tôt était relativement simple. Il ne gère aucun état, observateur ou état passé du dessus, et il n'a aucune méthode de cycle de vie. Non, ce n'est qu'une simple fonction avec quelque props.
+Le composant de titre ancré que nous avons créé plus tôt était relativement simple. Il ne gère aucun état, n'observe aucun état qu'on lui passe, et il n'a pas de méthodes de cycle de vie. Non, ce n'est qu'une simple fonction avec quelque props.
 
-Dans dès cas comme ça, nous pouvons marquer les composants comme `functional`, ce qui signifie qu'ils sont sans état (« stateless » c.-à-d. sans `data`) et sans instance (« instanceless » c.-à-d. sans contexte `this`). Un composant fonctionnel ressemble à ça :
+Dans des cas comme celui-ci, nous pouvons marquer les composants comme `functional`, ce qui signifie qu'ils sont sans état (« stateless » c.-à-d. sans `data`) et sans instance (« instanceless » c.-à-d. sans contexte `this`). Un composant fonctionnel ressemble à ça :
 
 ``` js
 Vue.component('my-component', {
@@ -468,25 +468,25 @@ Vue.component('my-component', {
 })
 ```
 
-> Note : dans les versions <= 2.3.0, l'option `props` est requise si vous souhaitez accepter des props dans un composant fonctionnel. Dans les versions 2.3.0+ vous pouvez omettre l'option `props` et tous les attributs trouvés dans le nœud composant seront implicitement extrait comme des props.
+> Note : dans les versions <= 2.3.0, l'option `props` est requise si vous souhaitez accepter des props dans un composant fonctionnel. Dans les versions 2.3.0+ vous pouvez omettre l'option `props` et tous les attributs trouvés dans le nœud composant seront implicitement extraits comme des props.
 
 Tout ce dont le composant a besoin est passé dans l'objet `context`, qui est un objet contenant :
 
 - `props`: un objet avec les props fournies,
-- `children`: un tableau de VNode enfant,
+- `children`: un tableau de VNode enfants,
 - `slots`: une fonction retournant un objet de slots,
 - `data`: l'objet de données (`data`) complet passé au composant,
 - `parent`: une référence au composant parent,
-- `listeners`: (2.3.0+) un objet contenant les écouteurs d'évènement enregistré du parent. C'est un simple alias de `data.on`,
+- `listeners`: (2.3.0+) un objet contenant les écouteurs d'évènement enregistrés dans le parent. C'est un simple alias de `data.on`,
 - `injections`: (2.3.0+) si vous utilisez l'option [`inject`](../api/#provide-inject), cela va contenir les injections résolues.
 
-Après avoir ajouté `functional: true`, mettre a jour la fonction de rendu de votre composant de titres avec ancres va seulement demander l'utilisation de l'argument `context`, la mise à jour de `this.$slots.default` pour `context.children`, puis la mise à jour de `this.level` pour `context.props.level`.
+Après avoir ajouté `functional: true`, mettre à jour la fonction de rendu de notre composant de titres avec ancres va simplement nécessiter d'ajouter l'argument `context`, en remplaçant `this.$slots.default` par `context.children`, puis `this.level` par `context.props.level`.
 
 Puisque les composants fonctionnels ne sont que des fonctions, leur rendu est plus rapide. Cependant, cela signifie également que les composants fonctionnels n'apparaissent pas dans l'arbre des composants de l'outil de développement Vue.js de Chrome.
 
-Ils sont également très utile en tant que composant encadrant. Par exemple, quand vous avez besoin de :
+Ils sont également très utiles en tant que composants enveloppes. Par exemple, quand vous avez besoin de :
 
-- Programmatiquement choisir un composant parmi plusieurs autres composant pour de la délégation ou
+- Programmatiquement choisir un composant parmi plusieurs autres composants pour de la délégation ou
 - Manipuler les enfants, props, ou données avant de les passer au composant enfant.
 
 Voici un exemple d'un composant `smart-list` qui délègue à des composants plus spécifiques en fonction des props qui lui sont passées :
@@ -528,7 +528,7 @@ Vue.component('smart-list', {
 
 ### `slots()` vs. `children`
 
-Vous vous demandez peut-être l'utilité d'avoir `slot()` et `children` en même temps. `slots().default` n'est pas la même chose que `children` ? Dans la majorité des cas, oui. Mais que faire si vous avez le composant fonctionnel suivant avec les enfants suivants ?
+Vous vous demandez peut-être l'utilité d'avoir `slot()` et `children` en même temps. `slots().default` n'est-il pas la même chose que `children` ? Dans la majorité des cas, oui. Mais que faire si vous avez un composant fonctionnel avec les enfants suivants ?
 
 ``` html
 <my-functional-component>
@@ -539,11 +539,11 @@ Vous vous demandez peut-être l'utilité d'avoir `slot()` et `children` en même
 </my-functional-component>
 ```
 
-Pour ce composant `children` va vous donner les deux paragraphes, `slots().default` ne vous donnera que le second, et `slots().foo` ne vous donnera que le premier. Avoir le choix entre `children` et `slots()` donc a vous de choisir ce que le composant sait à propos du système de slot ou si vous déléguez peut-être la responsabilité à un autre composant en passant simplement `children`.
+Pour ce composant, `children` va vous donner les deux paragraphes, `slots().default` ne vous donnera que le second, et `slots().foo` ne vous donnera que le premier. Avoir le choix entre `children` et `slots()` vous permet donc de choisir ce que le composant sait à propos du système de slot ou si vous déléguez peut-être la responsabilité à un autre composant en passant simplement `children`.
 
 ## Compilation de template
 
-Vous serez peut-être intéresser de savoir que les templates Vue sont en fait compilé en fonctions de rendu. C'est un détail d'implémentation dont vous avez en général pas à vous soucier, mais si vous souhaiter savoir comment un template spécifique est compilé, vous pourrez trouver cela intéressant. Vous trouverez ci-dessous une petite démo utilisant `Vue.compile` pour voir en live le rendu d'une chaîne de template :
+Vous serez peut-être intéressé de savoir que les templates Vue sont en fait compilés en fonctions de rendu. C'est un détail d'implémentation dont vous n'avez en général pas à vous soucier, mais si vous souhaitez savoir comment un template spécifique est compilé, vous pourrez trouver cela intéressant. Vous trouverez ci-dessous une petite démo utilisant `Vue.compile` pour voir en live le rendu d'une chaîne de template :
 
 {% raw %}
 <div id="vue-compile-demo" class="demo">

From 53930bd1ace72d296428dba6e82a389e3c75a025 Mon Sep 17 00:00:00 2001
From: Bruno Lesieur <bruno.lesieur@gmail.com>
Date: Thu, 15 Jun 2017 18:38:20 +0200
Subject: [PATCH 6/7] Ajustement avec les retours de @kokal et @forrest

Signed-off-by: Bruno Lesieur <bruno.lesieur@gmail.com>
---
 src/v2/guide/render-function.md | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/v2/guide/render-function.md b/src/v2/guide/render-function.md
index 3d37db36bf..afdea4cb44 100644
--- a/src/v2/guide/render-function.md
+++ b/src/v2/guide/render-function.md
@@ -6,9 +6,9 @@ order: 15
 
 ## Les bases
 
-Vue vous recommande l'utilisation de templates pour construire votre HTML dans la grande majorité des cas. Il y a cependant des situation ou vous aurez réellement besoin de toute la puissance programmatique de JavaScript. C'est là que vous pouvez utiliser les **fonctions de rendu**, une alternative aux templates qui est plus proche du compilateur.
+Vue vous recommande l'utilisation de templates pour construire votre HTML dans la grande majorité des cas. Il y a cependant des situations où vous aurez réellement besoin de toute la puissance programmatique de JavaScript. C'est là que vous pouvez utiliser les **fonctions de rendu**, une alternative aux templates qui est plus proche du compilateur.
 
-Voyons un simple exemple où une fonction `render` serait plus pratique. Imaginons que nous souhaitons générer des titres avec une ancre :
+Examinons un exemple simple où une fonction `render` serait plus pratique. Imaginons que nous souhaitons générer des titres avec une ancre :
 
 ``` html
 <h1>
@@ -147,7 +147,7 @@ Une chose est à noter : de la même manière que `v-bind:class` et `v-bind:styl
   domProps: {
     innerHTML: 'baz'
   },
-  // La gestion d'évènement est regroupée sous `on` cependant
+  // La gestion d'évènements est regroupée sous `on` cependant
   // les modificateurs comme `v-on:keyup.enter` ne sont pas
   // supportés. Vous devez vérifier manuellement le code de touche
   // dans le gestionnaire à la place.
@@ -240,7 +240,7 @@ Tous les VNodes dans l'arbre des composants doivent être uniques. Cela signifie
 render: function (createElement) {
   var myParagraphVNode = createElement('p', 'hi')
   return createElement('div', [
-    // Erf - VNodes dupliqués !
+    // Aïe - VNodes dupliqués !
     myParagraphVNode, myParagraphVNode
   ])
 }
@@ -306,11 +306,11 @@ render: function (createElement) {
 }
 ```
 
-C'est le prix à payer pour travailler à bas niveau, mais cela vous donne un meilleur contrôle sur le détail des interactions comparé à `v-model`.
+C'est le prix à payer pour travailler au plus bas niveau, mais cela vous donne un meilleur contrôle sur le détail des interactions comparé à `v-model`.
 
 ### Modificateurs d'évènement et de code de touche
 
-Pour les modificateurs d'évènement `.capture` et `.once`, Vue offre des préfixes pouvant être utilisé dans `on`:
+Pour les modificateurs d'évènement `.capture` et `.once`, Vue offre des préfixes pouvant être utilisés dans `on`:
 
 | Modificateur(s) | Préfixes |
 | ------ | ------ |
@@ -403,7 +403,7 @@ render (createElement) {
 
 ## JSX
 
-Si vous écrivez beaucoup de fonctions de rendu, cela pourra vous sembler fatiguant d'écrire des choses comme ça :
+Si vous écrivez beaucoup de fonctions `render`, cela pourra vous sembler fatiguant d'écrire des choses comme ça :
 
 ``` js
 createElement(
@@ -449,7 +449,7 @@ Pour plus d'informations sur comment utiliser JSX dans du JavaScript, référez-
 
 ## Composants fonctionnels
 
-Le composant de titre ancré que nous avons créé plus tôt était relativement simple. Il ne gère aucun état, n'observe aucun état qu'on lui passe, et il n'a pas de méthodes de cycle de vie. Non, ce n'est qu'une simple fonction avec quelque props.
+Le composant de titre ancré que nous avons créé plus tôt était relativement simple. Il ne gère aucun état, n'observe aucun état qu'on lui passe, et il n'a pas de méthodes de cycle de vie. Non, ce n'est qu'une simple fonction avec quelques props.
 
 Dans des cas comme celui-ci, nous pouvons marquer les composants comme `functional`, ce qui signifie qu'ils sont sans état (« stateless » c.-à-d. sans `data`) et sans instance (« instanceless » c.-à-d. sans contexte `this`). Un composant fonctionnel ressemble à ça :
 
@@ -472,13 +472,13 @@ Vue.component('my-component', {
 
 Tout ce dont le composant a besoin est passé dans l'objet `context`, qui est un objet contenant :
 
-- `props`: un objet avec les props fournies,
-- `children`: un tableau de VNode enfants,
-- `slots`: une fonction retournant un objet de slots,
-- `data`: l'objet de données (`data`) complet passé au composant,
-- `parent`: une référence au composant parent,
-- `listeners`: (2.3.0+) un objet contenant les écouteurs d'évènement enregistrés dans le parent. C'est un simple alias de `data.on`,
-- `injections`: (2.3.0+) si vous utilisez l'option [`inject`](../api/#provide-inject), cela va contenir les injections résolues.
+- `props` : un objet avec les props fournies,
+- `children` : un tableau de VNode enfants,
+- `slots` : une fonction retournant un objet de slots,
+- `data` : l'objet de données (`data`) complet passé au composant,
+- `parent` : une référence au composant parent,
+- `listeners` : (2.3.0+) un objet contenant les écouteurs d'évènement enregistrés dans le parent. C'est un simple alias de `data.on`,
+- `injections` : (2.3.0+) si vous utilisez l'option [`inject`](../api/#provide-inject), cela va contenir les injections résolues.
 
 Après avoir ajouté `functional: true`, mettre à jour la fonction de rendu de notre composant de titres avec ancres va simplement nécessiter d'ajouter l'argument `context`, en remplaçant `this.$slots.default` par `context.children`, puis `this.level` par `context.props.level`.
 

From cdcfa2b7765931fa4efbcbf8ef29e0a672869c22 Mon Sep 17 00:00:00 2001
From: Bruno Lesieur <bruno.lesieur@gmail.com>
Date: Thu, 15 Jun 2017 18:43:46 +0200
Subject: [PATCH 7/7] =?UTF-8?q?Commentaire=20pass=C3=A9s=20=C3=A0=20la=20t?=
 =?UTF-8?q?rappe?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Bruno Lesieur <bruno.lesieur@gmail.com>
---
 src/v2/guide/render-function.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/v2/guide/render-function.md b/src/v2/guide/render-function.md
index afdea4cb44..91764042f0 100644
--- a/src/v2/guide/render-function.md
+++ b/src/v2/guide/render-function.md
@@ -71,8 +71,8 @@ Alors que les templates fonctionnent bien pour la plupart des composants, il est
 Vue.component('anchored-heading', {
   render: function (createElement) {
     return createElement(
-      'h' + this.level,   // tag name
-      this.$slots.default // array of children
+      'h' + this.level,   // nom de balise
+      this.$slots.default // tableau des enfants
     )
   },
   props: {