You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Copy file name to clipboardExpand all lines: src/content/reference/react/use-server.md
+71-70Lines changed: 71 additions & 70 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -34,77 +34,77 @@ async function addToCart(data) {
34
34
}
35
35
```
36
36
37
-
When calling a server action on the client, it will make a network request to the server that includes a serialized copy of any arguments passed. If the server action returns a value, that value will be serialized and returned to the client.
37
+
Lorsque vous appelez une action serveur côté client, elle fait une requête réseau auprès du serveur en incluant une copie sérialisée des arguments que vous avez passés. Si l'action serveur renvoie une valeur, cette valeur sera sérialisée puis renvoyée au client.
38
38
39
-
Instead of individually marking functions with `'use server'`, you can add the directive to the top of a file to mark all exports within that file as server actions that can be used anywhere, including imported in client code.
39
+
Plutôt que de marquer chaque fonction concernée avec `'use server'`, vous pouvez ajouter cette directive tout en haut d'un fichier afin d'en marquer tous les exports comme des actions serveur utilisables n'importe où, y compris au travers d'imports par du code client.
40
40
41
41
#### Limitations {/*caveats*/}
42
42
43
-
*`'use server'`must be at the very beginning of their function or module; above any other code including imports (comments above directives are OK). They must be written with single or double quotes, not backticks.
44
-
*`'use server'`can only be used in server-side files. The resulting server actions can be passed to Client Components through props. See supported [types for serialization](#serializable-parameters-and-return-values).
45
-
*To import a server action from [client code](/reference/react/use-client), the directive must be used on a module level.
46
-
*Because the underlying network calls are always asynchronous, `'use server'`can only be used on async functions.
47
-
*Always treat arguments to server actions as untrusted input and authorize any mutations. See [security considerations](#security).
48
-
*Server actions should be called in a [transition](/reference/react/useTransition). Server actions passed to [`<form action>`](/reference/react-dom/components/form#props)or[`formAction`](/reference/react-dom/components/input#props)will automatically be called in a transition.
49
-
*Server actions are designed for mutations that update server-side state; they are not recommended for data fetching. Accordingly, frameworks implementing server actions typically process one action at a time and do not have a way to cache the return value.
43
+
*`'use server'`doit être placé au tout début de la fonction ou du module concerné ; au-dessus notamment de tout code, y compris les imports (mais il peut y avoir des commentaires avant les directives). Elles doivent utiliser des apostrophes (`'`) ou guillemets (`"`), mais pas des *backticks* (<code>`</code>).
44
+
*`'use server'`ne peut être utilisé qu'au sein de fichiers côté serveur. Les actions serveur résultantes peuvent être passées à des composants côté client au moyen des props. Consultez la liste des [types sérialisables](#serializable-parameters-and-return-values).
45
+
*Pour importer une action serveur depuis du [code côté client](/reference/react/use-client), la directive doit obligatoirement être utilisée au niveau du module.
46
+
*Dans la mesure où les appels réseau sous-jacents sont forcément asynchrones, `'use server'`n'est utilisable qu'au sein de fonctions asynchrones.
47
+
*Considérez toujours les arguments de vos actions serveur comme des données non validées, et soumettez toute mutation à un processus d'autorisation. Allez voir les [considérations sécuritaires](#security).
48
+
*Les actions serveur devraient toujours être appelées au sein d'une [transition](/reference/react/useTransition). Les actions serveur passées à [`<form action>`](/reference/react-dom/components/form#props)ou[`formAction`](/reference/react-dom/components/input#props)seront automatiquement enrobées par une transition.
49
+
*Les actions serveur sont conçues pour des mutations qui mettent à jour l'état côté serveur ; il est déconseillé de s'en servir pour du simple chargement de données. Dans cet esprit, les frameworks qui implémentent les actions serveur traitent généralement une action à la fois et ne permettent pas la mise en cache de leur valeur renvoyée.
50
50
51
-
### Security considerations {/*security*/}
51
+
### Considérations sécuritaires {/*security*/}
52
52
53
-
Arguments to server actions are fully client-controlled. For security, always treat them as untrusted input, and make sure to validate and escape arguments as appropriate.
53
+
Les arguments passés aux actions serveur sont entièrement contrôlés par le côté client. Pour des raisons de sécurité, traitez-les toujours comme des données non validées, et assurez-vous d'en vérifier la structure et le contenu, et de procéder à leur échappement lorsque c'est nécessaire.
54
54
55
-
In any server action, make sure to validate that the logged-in user is allowed to perform that action.
55
+
Par ailleurs, et quelle que soit l'action serveur, assurez-vous toujours que l'utilisateur authentifié a le droit d'effectuer cette action.
56
56
57
57
<Wip>
58
58
59
-
To prevent sending sensitive data from a server action, there are experimental taint APIs to prevent unique values and objects from being passed to client code.
59
+
Pour éviter le renvoi de données sensibles par une action serveur, nous proposons des API expérimentales empêchant l'envoi vers du code côté client de valeurs et objets uniques « ternis ».
60
60
61
-
See [experimental_taintUniqueValue](/reference/react/experimental_taintUniqueValue)and[experimental_taintObjectReference](/reference/react/experimental_taintObjectReference).
61
+
Allez jeter un coup d'œil à [experimental_taintUniqueValue](/reference/react/experimental_taintUniqueValue)et[experimental_taintObjectReference](/reference/react/experimental_taintObjectReference).
62
62
63
63
</Wip>
64
64
65
-
### Serializable arguments and return values {/*serializable-parameters-and-return-values*/}
66
-
67
-
As client code calls the server action over the network, any arguments passed will need to be serializable.
68
-
69
-
Here are supported types for server action arguments:
* [symbol](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol), only symbols registered in the global Symbol registry via [`Symbol.for`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/for)
* [TypedArray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) and [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)
*Plain [objects](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object): those created with [object initializers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer), with serializable properties
*Objects that are instances of any class (other than the built-ins mentioned) or objects with [a null prototype](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object#null-prototype_objects)
96
-
*Symbols not registered globally, ex. `Symbol('my new symbol')`
97
-
98
-
99
-
Supported serializable return values are the same as [serializable props](/reference/react/use-client#passing-props-from-server-to-client-components)for a boundary Client Component.
65
+
### Arguments et valeurs renvoyées sérialisables {/*serializable-parameters-and-return-values*/}
66
+
67
+
Lorsque du code côté client appelle l'action serveur au travers du réseau, tout argument passé aura besoin d'être sérialisé.
68
+
69
+
Voici les types pris en charge pour les arguments d'une action serveur :
* [symbol](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Global_Objects/Symbol), mais uniquement pour ceux inscrits auprès du référentiel global de symboles *via* [`Symbol.for`](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Global_Objects/Symbol/for)
79
+
*Les itérables contenant des valeurs sérialisables
* [TypedArray](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) et [ArrayBuffer](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)
*Les instances de [FormData](https://developer.mozilla.org/fr/docs/Web/API/FormData)
87
+
*Les [objets](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Global_Objects/Object) bruts : ceux créés via des [initialiseurs d'objets](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Operators/Object_initializer), dont les propriétés sont sérialisables
*Les objets de quelque classe que ce soit (hormis les classes natives explicitement listées plus haut) ainsi que les objets ayant [un prototype nul](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object#null-prototype_objects)
97
+
* Les symboles non inscrits au global, ex. `Symbol('my new symbol')`
98
+
99
+
Les valeurs renvoyées sérialisables sont les mêmes que pour les [props sérialisables](/reference/react/use-client#passing-props-from-server-to-client-components)d'un composant client agissant comme frontière client / serveur.
100
100
101
101
## Utilisation {/*usage*/}
102
102
103
-
### Server actions in forms {/*server-actions-in-forms*/}
103
+
### Les actions serveur dans les formulaires {/*server-actions-in-forms*/}
104
104
105
-
The most common use case of server actions will be calling server functions that mutate data. On the browser, the [HTML form element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form)is the traditional approach for a user to submit a mutation. With React Server Components, React introduces first-class support for server actions in [forms](/reference/react-dom/components/form).
105
+
Le cas le plus courant d'actions serveur consiste à appeler des fonctions côté serveur pour modifier des données. Dans le navigateur, on utilise traditionnellement [l'élément HTML `form`](https://developer.mozilla.org/fr/docs/Web/HTML/Element/form)pour permettre à l'utilisateur de demander une mutation de données. Avec les React Server Components, React prend désormais pleinement en charge les actions serveur dans les [formulaires](/reference/react-dom/components/form).
106
106
107
-
Here is a form that allows a user to request a username.
107
+
Voici un formulaire qui permet à l'utilisateur de réserver un identifiant.
108
108
109
109
```js [[1, 3, "formData"]]
110
110
// App.js
@@ -118,20 +118,20 @@ async function requestUsername(formData) {
118
118
exportdefaultApp() {
119
119
<form action={requestUsername}>
120
120
<input type="text" name="username"/>
121
-
<button type="submit">Request</button>
121
+
<button type="submit">Réserver</button>
122
122
</form>
123
123
}
124
124
```
125
125
126
-
In this example`requestUsername`is a server action passed to a `<form>`. When a user submits this form, there is a network request to the server function `requestUsername`. When calling a server action in a form, React will supply the form's <CodeStepstep={1}>[FormData](https://developer.mozilla.org/en-US/docs/Web/API/FormData)</CodeStep> as the first argument to the server action.
126
+
Dans cet exemple,`requestUsername`est une action serveur passée à un `<form>`. Lorsque l'utilisateur envoie le formulaire, une requête réseau est faite à l'action serveur `requestUsername`. Puisque celle-ci est appelée au travers d'un formulaire, React fournit les <CodeStepstep={1}>[FormData](https://developer.mozilla.org/fr/docs/Web/API/FormData)</CodeStep> du formulaire comme premier argument à l'action serveur.
127
127
128
-
By passing a server action to the form `action`, React can [progressively enhance](https://developer.mozilla.org/en-US/docs/Glossary/Progressive_Enhancement)the form. This means that forms can be submitted before the JavaScript bundle is loaded.
128
+
Grâce au passage d'une action serveur comme `action` du formulaire, React peut faire [l'amélioration progressive](https://developer.mozilla.org/fr/docs/Glossary/Progressive_Enhancement)du formulaire. Ça signifie que les formulaires peuvent être envoyés avant même que le *bundle* JavaScript ne soit chargé et exécuté.
129
129
130
-
#### Handling return values in forms {/*handling-return-values*/}
130
+
#### Gérer les valeurs renvoyées dans les formulaires {/*handling-return-values*/}
131
131
132
-
In the username request form, there might be the chance that a username is not available. `requestUsername`should tell us if it fails or not.
132
+
Pour revenir à notre formulaire de réservation d'identifiant, il peut arriver que l'identifiant ne soit plus disponible. `requestUsername`devrait nous indiquer si elle a réussi ou non sa réservation.
133
133
134
-
To update the UI based on the result of a server action while supporting progressive enhancement, use[`useFormState`](/reference/react-dom/hooks/useFormState).
134
+
Pour mettre à jour l'UI sur base du résultat d'une action serveur, tout en proposant une amélioration progressive, utilisez[`useFormState`](/reference/react-dom/hooks/useFormState).
135
135
136
136
```js
137
137
// requestUsername.js
@@ -141,41 +141,41 @@ export default async function requestUsername(formData) {
<p>Résultat de la dernière réservation : {returnValue}</p>
167
167
</>
168
168
);
169
169
}
170
170
```
171
171
172
-
Note that like most Hooks, `useFormState` can only be called in <CodeStepstep={1}>[client code](/reference/react/use-client)</CodeStep>.
172
+
Remarquez que `useFormState`, au même titre que la plupart des Hooks, ne peut être appelé que depuis du <CodeStepstep={1}>[code côté client](/reference/react/use-client)</CodeStep>.
173
173
174
-
### Calling a server action outside of`<form>` {/*calling-a-server-action-outside-of-form*/}
174
+
### Appeler une action serveur hors d'un`<form>` {/*calling-a-server-action-outside-of-form*/}
175
175
176
-
Server actions are exposed server endpoints and can be called anywhere in client code.
176
+
Les actions serveur exposent en pratique des points d'entrée côté serveur, et peuvent être appelées n'importe où dans du code client.
177
177
178
-
When using a server action outside of a [form](/reference/react-dom/components/form), call the server action in a[transition](/reference/react/useTransition), which allows you to display a loading indicator, show [optimistic state updates](/reference/react/useOptimistic), and handle unexpected errors. Forms will automatically wrap server actions in transitions.
178
+
Pour utiliser une action serveur hors d'un [formulaire](/reference/react-dom/components/form), appelez l'action serveur au sein d'une[transition](/reference/react/useTransition), ce qui vous permettra non seulement d'afficher un indicateur de chargement, mais aussi de réaliser des [mises à jour optimistes d'état](/reference/react/useOptimistic) et de gérer les éventuelles erreurs. Les formulaires enrobent automatiquement vos actions serveur dans une transition.
0 commit comments