Traduction `mutations.md` #11

MachinisteWeb · 2017-05-20T09:43:06Z

À priori le nombre de ligne à changé. Il doit y avoir du nouveau par ici :)

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

Kocal

C'est tout pour moi !

Kocal · 2017-05-20T10:04:22Z

docs/en/mutations.md

@@ -1,6 +1,6 @@
 # Mutations

-The only way to actually change state in a Vuex store is by committing a mutation. Vuex mutations are very similar to events: each mutation has a string **type** and a **handler**. The handler function is where we perform actual state modifications, and it will receive the state as the first argument:
+La seule façon de vraiment modifier le state dans un store Vuex est de commiter une mutation. Les mutations Vuex sont très similaires aux events : chaque mutation a un **type** sous forme de chaîne de caractères et un **handler**. La fonction handler est là où nous procédons aux véritables modifications du state, et elle reçoit le state en premier argument :


modifier l'état

est d'acter

reçoit l'état

Kocal · 2017-05-20T10:05:30Z

docs/en/mutations.md

@@ -16,15 +16,15 @@ const store = new Vuex.Store({
 })
 ```

-You cannot directly call a mutation handler. The options here is more like event registration: "When a mutation with type `increment` is triggered, call this handler." To invoke a mutation handler, you need to call **store.commit** with its type:
+Vous ne pouvez pas appeler directement un handler de mutation. La façon de faire est plutôt comme un abonnement à un event : "Lorsqu'une mutation du type `increment` est déclenchée, appelle ce handler." Pour invoquer un handler de mutation, il faut appeler **store.commit** avec son type :


à un événement

Kocal · 2017-05-20T10:06:12Z

docs/en/mutations.md

@@ -56,7 +56,7 @@ store.commit('increment', {

 ### Object-Style Commit

-An alternative way to commit a mutation is by directly using an object that has a `type` property:
+Une méthode alternative pour commiter une mutation est d'utiliser directement un objet qui a une propriété `type` :


Kocal · 2017-05-20T10:08:00Z

docs/en/mutations.md


-Since a Vuex store's state is made reactive by Vue, when we mutate the state, Vue components observing the state will update automatically. This also means Vuex mutations are subject to the same reactivity caveats when working with plain Vue:
+Puisqu'un state de store de Vuex est rendu réactif par Vue, lorsque nous mutons le state, les composants Vue observant ce state seront automatiquement mis à jour. Cela signifie également que les mutations Vuex sont sujettes aux mêmes inconvénients que lorsqu'on travaille avec Vue :


Puisqu'un état de

observant cet état

Kocal · 2017-05-20T10:08:25Z

docs/en/mutations.md


-1. Prefer initializing your store's initial state with all desired fields upfront.
+1. Initialisez de préférence le state initial de votre state avec tous les champs désirés auparavant.


l'état initial de votre état

Kocal · 2017-05-20T10:12:13Z

docs/en/mutations.md


-You can commit mutations in components with `this.$store.commit('xxx')`, or use the `mapMutations` helper which maps component methods to `store.commit` calls (requires root `store` injection):
+Vous pouvez commiter des mutations dans les composants avec `this.$store.commit('xxx')`, ou en utilisant le helper `mapMutations` qui attache les méthodes du composant aux appels de `store.commit` (nécessite l'injection de `store` à la racine) :


Vous pouvez acter

Kocal · 2017-05-20T10:14:11Z

docs/en/mutations.md

-
-      // mapMutations also supports payloads:
-      'incrementBy' // this.incrementBy(amount) maps to this.$store.commit('incrementBy', amount)
+      'increment' // map this.increment() to this.$store.commit('increment')


map this.increment() à this.$store.commit('increment)

Kocal · 2017-05-20T10:15:10Z

docs/en/mutations.md

-      'increment', // map this.increment() to this.$store.commit('increment')
-
-      // mapMutations also supports payloads:
-      'incrementBy' // this.incrementBy(amount) maps to this.$store.commit('incrementBy', amount)


Cette partie a disparu.

Rajoutée dans 102eb49.

Kocal · 2017-05-20T10:15:35Z

docs/en/mutations.md

-
-      // mapMutations also supports payloads:
-      'incrementBy' // this.incrementBy(amount) maps to this.$store.commit('incrementBy', amount)
+      'increment' // map this.increment() to this.$store.commit('increment')
    ]),
    ...mapMutations({
      add: 'increment' // map this.add() to this.$store.commit('increment')


map this.add() à this.$store.commit('increment')

Kocal · 2017-05-20T10:16:05Z

docs/en/mutations.md


-Asynchronicity combined with state mutation can make your program very hard to reason about. For example, when you call two methods both with async callbacks that mutate the state, how do you know when they are called and which callback was called first? This is exactly why we want to separate the two concepts. In Vuex, **mutations are synchronous transactions**:
+L'asynchronisme combiné à la mutation du state peut rendre votre programme très difficile à comprendre. Par exemple, lorsque vous appelez deux méthodes avec toutes les deux des callbacks asynchrones qui changent le state, comment savez-vous quand elles sont appelées et quel callback est appelé en premier ? C'est exactement la raison pour laquelle nous voulons séparer les deux concepts. Avec Vuex, **les mutations sont des transactions synchrones** :


la mutation de l'état

qui changent l'état

MachinisteWeb

Un peu de travail de ce côté et une petite reflexion sur le terme « linters » est a envisagé

MachinisteWeb · 2017-05-20T09:43:58Z

docs/en/mutations.md

@@ -1,6 +1,6 @@
 # Mutations

-The only way to actually change state in a Vuex store is by committing a mutation. Vuex mutations are very similar to events: each mutation has a string **type** and a **handler**. The handler function is where we perform actual state modifications, and it will receive the state as the first argument:
+La seule façon de vraiment modifier le state dans un store Vuex est de commiter une mutation. Les mutations Vuex sont très similaires aux events : chaque mutation a un **type** sous forme de chaîne de caractères et un **handler**. La fonction handler est là où nous procédons aux véritables modifications du state, et elle reçoit le state en premier argument :


modifier l'état

est d'acter

aux évènements

et un gestionnaire

La fonction de gestion est en charge de procéder aux véritables modifications de l'état

MachinisteWeb · 2017-05-20T09:47:07Z

docs/en/mutations.md

@@ -16,15 +16,15 @@ const store = new Vuex.Store({
 })


À traduire

muter l'état

MachinisteWeb · 2017-05-20T09:49:58Z

docs/en/mutations.md

@@ -16,15 +16,15 @@ const store = new Vuex.Store({
 })
 ```

-You cannot directly call a mutation handler. The options here is more like event registration: "When a mutation with type `increment` is triggered, call this handler." To invoke a mutation handler, you need to call **store.commit** with its type:
+Vous ne pouvez pas appeler directement un handler de mutation. La façon de faire est plutôt comme un abonnement à un event : "Lorsqu'une mutation du type `increment` est déclenchée, appelle ce handler." Pour invoquer un handler de mutation, il faut appeler **store.commit** avec son type :


un gestionnaire de mutation.

Le partie pris ici est similaire à l'abonnement à un évènement : « ... ce gestionnaire. »

un gestionnaire de mutation

appeler store.commit

MachinisteWeb · 2017-05-20T09:52:08Z

docs/en/mutations.md


 ``` js
 store.commit('increment')
 ```

-### Commit with Payload
+### commiter avec un Payload


Acter avec un argument additionnel

MachinisteWeb · 2017-05-20T09:53:23Z

docs/en/mutations.md


-You can pass an additional argument to `store.commit`, which is called the **payload** for the mutation:
+Vous pouvez donner un autre argument à **store.commit** pour la mutation, qui s'appelle **payload** :


Vous pouvez donner un argument additionnel (« payload ») à la fonction store.commit lors de la mutation :

MachinisteWeb · 2017-05-20T10:14:42Z

docs/en/mutations.md

@@ -133,11 +133,11 @@ mutations: {
 }
 ```

-Now imagine we are debugging the app and looking at the devtool's mutation logs. For every mutation logged, the devtool will need to capture a "before" and "after" snapshots of the state. However, the asynchronous callback inside the example mutation above makes that impossible: the callback is not called yet when the mutation is committed, and there's no way for the devtool to know when the callback will actually be called - any state mutation performed in the callback is essentially un-trackable!
+Maintenant imaginons que nous debuggons l'application et que nous regardons dans les logs de mutation des devtools. Pour chaque mutation enregistrée, le devtool aura besoin de capturer un instantané du state "avant" et un instantané "après". Cependant, le callback asynchrone du l'exemple ci-dessus rend l'opération impossible : le callback n'est pas encore appelé lorsque la mutation est committée, et il n'y a aucun moyen pour le devtool de savoir quand le callback sera véritablement appelé &mdash; toute mutation du state effectuée dans le callack est essentiellement intraçable !


deboguons

des outils de développement (« devtools »)

« avant »

« après »

la fonction de rappel asynchrone

la fonction de rappel n'est pas encore appelée

la mutation est actée

quand la fonction de rappel

appelée. Toute mutation de l'état effectuée dans une fonction de rappel asynchrone

MachinisteWeb · 2017-05-20T10:18:03Z

docs/en/mutations.md


-### Committing Mutations in Components
+### commiter des mutations dans les composants


MachinisteWeb · 2017-05-20T10:18:44Z

docs/en/mutations.md


-You can commit mutations in components with `this.$store.commit('xxx')`, or use the `mapMutations` helper which maps component methods to `store.commit` calls (requires root `store` injection):
+Vous pouvez commiter des mutations dans les composants avec `this.$store.commit('xxx')`, ou en utilisant le helper `mapMutations` qui attache les méthodes du composant aux appels de `store.commit` (nécessite l'injection de `store` à la racine) :


pouvez acter

la fonction utilitaire mapMutations

MachinisteWeb · 2017-05-20T10:18:58Z

docs/en/mutations.md

@@ -158,14 +155,14 @@ export default {
 }


À traduire

MachinisteWeb · 2017-05-20T10:20:30Z

docs/en/mutations.md


-Asynchronicity combined with state mutation can make your program very hard to reason about. For example, when you call two methods both with async callbacks that mutate the state, how do you know when they are called and which callback was called first? This is exactly why we want to separate the two concepts. In Vuex, **mutations are synchronous transactions**:
+L'asynchronisme combiné à la mutation du state peut rendre votre programme très difficile à comprendre. Par exemple, lorsque vous appelez deux méthodes avec toutes les deux des callbacks asynchrones qui changent le state, comment savez-vous quand elles sont appelées et quel callback est appelé en premier ? C'est exactement la raison pour laquelle nous voulons séparer les deux concepts. Avec Vuex, **les mutations sont des transactions synchrones** :


de l'état

fonctions de rappel asynchrones qui change l'état

fonction de rappel est appelée en première ?

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

MachinisteWeb · 2017-05-22T12:07:29Z

docs/en/mutations.md


-Asynchronicity combined with state mutation can make your program very hard to reason about. For example, when you call two methods both with async callbacks that mutate the state, how do you know when they are called and which callback was called first? This is exactly why we want to separate the two concepts. In Vuex, **mutations are synchronous transactions**:
+L'asynchronisme combiné à la mutation du state peut rendre votre programme très difficile à comprendre. Par exemple, lorsque vous appelez deux méthodes avec toutes les deux des callbacks asynchrones qui changent le state, comment savez-vous quand elles sont appelées et quel callback est appelé en premier ? C'est exactement la raison pour laquelle nous voulons séparer les deux concepts. Avec Vuex, **les mutations sont des transactions synchrones** :

 ``` js
 store.commit('increment')
 // any state change that the "increment" mutation may cause
 // should be done at this moment.


À traduire

MachinisteWeb · 2017-05-22T12:12:21Z

Si c'est bon pour toi @Kocal, on merge. Je vais faire une PR en pour remettre les ticks dans l'original.

Kocal · 2017-05-22T12:28:06Z

Ok pour moi :)

Starting review for mutations.md

73c8d0f

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

MachinisteWeb added the Relecture nécessaire label May 20, 2017

MachinisteWeb self-assigned this May 20, 2017

MachinisteWeb requested review from darenju and Kocal May 20, 2017 09:43

Kocal requested changes May 20, 2017

View reviewed changes

MachinisteWeb commented May 20, 2017

View reviewed changes

MachinisteWeb added 2 commits May 22, 2017 12:15

Merge branch 'working' into mutation

0f73e76

Add changes after @haeresis and @kokal review.

102eb49

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

MachinisteWeb commented May 22, 2017

View reviewed changes

Kocal approved these changes May 22, 2017

View reviewed changes

MachinisteWeb merged commit e17989a into working May 22, 2017

MachinisteWeb deleted the mutation branch May 22, 2017 13:03

MachinisteWeb mentioned this pull request May 22, 2017

État des traductions #1

Open

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Traduction `mutations.md` #11

Traduction `mutations.md` #11

MachinisteWeb commented May 20, 2017 •

edited

Loading

Kocal left a comment

Kocal May 20, 2017

Kocal May 20, 2017

Kocal May 20, 2017

Kocal May 20, 2017

Kocal May 20, 2017

Kocal May 20, 2017

Kocal May 20, 2017

Kocal May 20, 2017

Kocal May 22, 2017

Kocal May 20, 2017

Kocal May 20, 2017

MachinisteWeb left a comment

MachinisteWeb May 20, 2017

MachinisteWeb May 20, 2017

MachinisteWeb May 20, 2017

MachinisteWeb May 20, 2017

MachinisteWeb May 20, 2017

MachinisteWeb May 20, 2017 •

edited

Loading

MachinisteWeb May 20, 2017

MachinisteWeb May 20, 2017

MachinisteWeb May 20, 2017

MachinisteWeb May 20, 2017 •

edited

Loading

MachinisteWeb May 22, 2017

MachinisteWeb commented May 22, 2017

Kocal commented May 22, 2017


		Since a Vuex store's state is made reactive by Vue, when we mutate the state, Vue components observing the state will update automatically. This also means Vuex mutations are subject to the same reactivity caveats when working with plain Vue:
		Puisqu'un state de store de Vuex est rendu réactif par Vue, lorsque nous mutons le state, les composants Vue observant ce state seront automatiquement mis à jour. Cela signifie également que les mutations Vuex sont sujettes aux mêmes inconvénients que lorsqu'on travaille avec Vue :


		1. Prefer initializing your store's initial state with all desired fields upfront.
		1. Initialisez de préférence le state initial de votre state avec tous les champs désirés auparavant.


		You can commit mutations in components with `this.$store.commit('xxx')`, or use the `mapMutations` helper which maps component methods to `store.commit` calls (requires root `store` injection):
		Vous pouvez commiter des mutations dans les composants avec `this.$store.commit('xxx')`, ou en utilisant le helper `mapMutations` qui attache les méthodes du composant aux appels de `store.commit` (nécessite l'injection de `store` à la racine) :


		Asynchronicity combined with state mutation can make your program very hard to reason about. For example, when you call two methods both with async callbacks that mutate the state, how do you know when they are called and which callback was called first? This is exactly why we want to separate the two concepts. In Vuex, mutations are synchronous transactions:
		L'asynchronisme combiné à la mutation du state peut rendre votre programme très difficile à comprendre. Par exemple, lorsque vous appelez deux méthodes avec toutes les deux des callbacks asynchrones qui changent le state, comment savez-vous quand elles sont appelées et quel callback est appelé en premier ? C'est exactement la raison pour laquelle nous voulons séparer les deux concepts. Avec Vuex, les mutations sont des transactions synchrones :


		You can pass an additional argument to `store.commit`, which is called the payload for the mutation:
		Vous pouvez donner un autre argument à store.commit pour la mutation, qui s'appelle payload :


		### Committing Mutations in Components
		### commiter des mutations dans les composants

Traduction mutations.md #11

Traduction mutations.md #11

Conversation

MachinisteWeb commented May 20, 2017 • edited Loading

Kocal left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

MachinisteWeb left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

MachinisteWeb May 20, 2017 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Acter

Choose a reason for hiding this comment

Choose a reason for hiding this comment

MachinisteWeb May 20, 2017 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

MachinisteWeb commented May 22, 2017

Kocal commented May 22, 2017

Traduction `mutations.md` #11

Traduction `mutations.md` #11

MachinisteWeb commented May 20, 2017 •

edited

Loading

MachinisteWeb May 20, 2017 •

edited

Loading

MachinisteWeb May 20, 2017 •

edited

Loading