Apply suggestions from code review

tdd · web-flow · commit 248c29bce428 · 2023-09-07T11:08:34.000+02:00
diff --git a/src/content/reference/react-dom/findDOMNode.md b/src/content/reference/react-dom/findDOMNode.md
@@ -4,13 +4,13 @@ title: findDOMNode
 
 <Deprecated>
 
-Cette API sera retirée dans une future version majeure de React. [Voir les solutions alternatives](#alternatives).
+Cette API sera retirée d'une future version majeure de React. [Découvrez les alternatives](#alternatives).
 
 </Deprecated>
 
 <Intro>
 
-`findDOMNode` trouve le nœud du navigateur pour une instance React à [composant à base de classe](/reference/react/Component).
+`findDOMNode` trouve le nœud DOM le plus proche associé à une instance de [composant à base de classe](/reference/react/Component).
 
 ```js
 const domNode = findDOMNode(componentInstance)
@@ -26,43 +26,43 @@ const domNode = findDOMNode(componentInstance)
 
 ### `findDOMNode(componentInstance)` {/*finddomnode*/}
 
-Appeler `findDOMNode` pour trouver le nœud du navigateur pour une instance React à [composant à base de classe](/reference/react/Component) donnée.
+Appelez `findDOMNode` pour trouver le nœud DOM associé à une instance de [composant React à base de classe](/reference/react/Component) donnée.
 
 ```js
 import { findDOMNode } from 'react-dom';
 
 const domNode = findDOMNode(componentInstance);
 ```
 
-[Voir les exemples ci-dessous](#usage).
+[Voir d'autres exemples ci-dessous](#usage).
 
 #### Paramètres {/*parameters*/}
 
-* `componentInstance` : Une instance de la sous-classe du [`Component`](/reference/react/Component). Par exemple `this` dans un composant à base de classe.
+* `componentInstance` : une instance de la sous-classe de [`Component`](/reference/react/Component). Par exemple, `this` dans un composant à base de classe.
 
 
 #### Valeur renvoyée {/*returns*/}
 
-`findDOMNode` renvoie le plus proche nœud du DOM du navigateur dans une `componentInstance` donnée. Lorsqu'un composant fait le rendu à `null`, fait le rendu à `false`, `findDOMNode` renvoie `null`. Lorsqu'un composant fait le rendu d'une string, `findDOMNode` renvoie un nœud DOM sous forme de texte contenant cette valeur.
+`findDOMNode` renvoie le plus proche nœud du DOM du navigateur dans une `componentInstance` donnée. Lorsque le rendu d'un composant renvoie `null` ou `false`, `findDOMNode` renvoie `null`. Lorsque le rendu renvoie une chaîne de caractères, `findDOMNode` renvoie un nœud DOM textuel contenant cette valeur.
 
 #### Limitations {/*caveats*/}
 
-* Un composant peut renvoyer un tableau ou un [Fragment](/reference/react/Fragment) avec plusieurs enfants. Dans ce cas `findDOMNode`, renverra le nœud du DOM correspondant au premier enfant non-vide.
+* Un composant est susceptible de renvoyer un tableau ou un [Fragment](/reference/react/Fragment) avec plusieurs enfants. Dans ce cas `findDOMNode`, renverra le nœud DOM correspondant au premier enfant non vide.
 
-* `findDOMNode` fonctionne seulement sur les composants montés (c'est-à-dire, les composants qui ont été placés dans le DOM). Si vous essayez d'appeler `this` sur un composant qui n'a pas encore été monté (comme l'appel de `findDOMNode()` dans `render()` sur un composant qui doit être crée), une exception sera levée.
+* `findDOMNode` fonctionne seulement sur les composants montés (c'est-à-dire les composants qui ont été placés dans le DOM). Si vous essayez de l'appeler sur un composant qui n'a pas encore été monté (comme un appel de `findDOMNode()` dans `render()` sur un composant qui n'a pas encore été créé), une exception sera levée.
 
-* `findDOMNode` renvoie seulement le résultat au moment de votre appel. Si un composant enfant fait plutard le rendu d'un nœud différent, vous n'avez aucun moyen d'être informé de ce changement.
+* `findDOMNode` renvoie seulement le résultat au moment de votre appel. Si un composant enfant renvoie plus tard un nœud différent, vous n'avez aucun moyen d'être informé·e de ce changement.
 
-* `findDOMNode` accepte une instance de composant à base de classe, il ne peut être utilisé avec les fonctions composants.
+* `findDOMNode` accepte une instance de composant à base de classe, il ne peut donc pas être utilisé avec des fonctions composants.
 
 ---
 
 ## Utilisation {/*usage*/}
 
-### Trouver le nœud racine du DOM d'un composant à base de classe {/*finding-the-root-dom-node-of-a-class-component*/}
+### Trouver le nœud DOM racine d'un composant à base de classe {/*finding-the-root-dom-node-of-a-class-component*/}
 
 
-Appeler `findDOMNode` avec une instance de [composant à base de classe](/reference/react/Component)  (généralement, `this`) pour trouver le nœud du DOM qu'il a affiché.
+Appelez `findDOMNode` avec une instance de [composant à base de classe](/reference/react/Component)  (ce sera généralement `this`) pour trouver le nœud DOM qu'il a affiché.
 
 ```js {3}
 class AutoselectingInput extends Component {
@@ -77,7 +77,7 @@ class AutoselectingInput extends Component {
 }
 ```
 
-Ici, la variable de `input` sera défini sur l'élément DOM `<input>`. Cela vous permet de faire quelque chose avec. Par exemple, en cliquant « voir l'exemple » ci-dessous, le champ de saisi est monté, [`input.select()`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/select) sélectionne tout le text dans le champ :
+Ici, la variable `input` sera définie à l'élément DOM `<input>`. Ça vous permet de le manipuler. Par exemple, en cliquant sur « voir l'exemple » ci-dessous, le champ de saisie est monté, puis [`input.select()`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/select) sélectionnera tout le texte dans le champ :
 
 <Sandpack>
 
@@ -90,7 +90,7 @@ export default function App() {
   return (
     <>
       <button onClick={() => setShow(true)}>
-        Voir l'exemple
+        Voir l’exemple
       </button>
       <hr />
       {show && <AutoselectingInput />}
@@ -123,9 +123,9 @@ export default AutoselectingInput;
 
 ## Alternatives {/*alternatives*/}
 
-### Lecture du nœud DOM à partir d'une ref {/*reading-components-own-dom-node-from-a-ref*/}
+### Lire le nœud DOM du composant à partir d'une ref {/*reading-components-own-dom-node-from-a-ref*/}
 
-Le code qui utilise `findDOMNode` est fragile parce que la connection entre le nœud JSX et le code manipulant le nœud du DOM correspondant n'est pas explicite. Par exemple, essayez d'enrober ce `<input />` dans un `<div>` :
+Un code qui utilise `findDOMNode` est fragile parce que la relation entre le nœud JSX et le code manipulant le nœud DOM correspondant n'est pas explicite. Essayez par exemple d'enrober cet `<input />` dans une `<div>` :
 
 <Sandpack>
 
@@ -138,7 +138,7 @@ export default function App() {
   return (
     <>
       <button onClick={() => setShow(true)}>
-        Voir l'exemple
+        Voir l’exemple
       </button>
       <hr />
       {show && <AutoselectingInput />}
@@ -166,9 +166,9 @@ export default AutoselectingInput;
 
 </Sandpack>
 
-Le code sera interrompu maintenant, `findDOMNode(this)` trouve le nœud `<div>` du DOM, mais le code attend un nœud DOM `<input>`. Pour éviter ce genre de problèmes, utilisez [`createRef`](/reference/react/createRef) pour gérer un nœud DOM spécifique.
+Ce code plantera parce que désormais, `findDOMNode(this)` trouvera le nœud DOM `<div>` alors qu'il s'attend à un nœud DOM `<input>`. Pour éviter ce genre de problème, utilisez [`createRef`](/reference/react/createRef) pour gérer un nœud DOM spécifique.
 
-Dans cet exemple, `findDOMNode` n'est plus utilisé. Par contre, `inputRef = createRef(null)` est défini comme champ d'instance de la classe. Pour lire le nœud du DOM à partir de celui-ci, vous pouvez utiliser `this.inputRef.current`. Pour le rattacher au JSX, vous faites le rendu `<input ref={this.inputRef} />`. Cela connecte le code utilisant le nœud DOM à son JSX :
+Dans cet exemple, `findDOMNode` n'est plus utilisé. On utilise plutôt `inputRef = createRef(null)` pour définir un champ d'instance. Pour y lire le nœud DOM, vous pouvez utiliser `this.inputRef.current`. Pour le rattacher au JSX, vous mettez dans votre rendu `<input ref={this.inputRef} />`. Ça connecte le code utilisant le nœud DOM à son JSX :
 
 <Sandpack>
 
@@ -181,7 +181,7 @@ export default function App() {
   return (
     <>
       <button onClick={() => setShow(true)}>
-        Afficher l'exemple
+        Afficher l’exemple
       </button>
       <hr />
       {show && <AutoselectingInput />}
@@ -213,7 +213,7 @@ export default AutoselectingInput;
 
 </Sandpack>
 
-Dans les versions modernes de React sans les composants à base de classe, le code équivalent appelerait [`useRef`](/reference/react/useRef) à la place :
+Dans les versions modernes de React sans les composants à base de classes, le code équivalent appellerait plutôt [`useRef`](/reference/react/useRef) :
 
 <Sandpack>
 
@@ -226,7 +226,7 @@ export default function App() {
   return (
     <>
       <button onClick={() => setShow(true)}>
-        Voir l'exemple
+        Voir l’exemple
       </button>
       <hr />
       {show && <AutoselectingInput />}
@@ -252,13 +252,13 @@ export default function AutoselectingInput() {
 
 </Sandpack>
 
-[En savoir plus sur la manipulation du DOM avec les refs](/learn/manipulating-the-dom-with-refs).
+[Apprenez-en davantage sur la manipulation du DOM avec les refs](/learn/manipulating-the-dom-with-refs).
 
 ---
 
-### Lecture d'un nœud DOM d'un composant enfant à partir d'un ref transmis {/*reading-a-child-components-dom-node-from-a-forwarded-ref*/}
+### Lire un nœud DOM d'un composant enfant à partir d'un ref transmis {/*reading-a-child-components-dom-node-from-a-forwarded-ref*/}
 
-Dans cet exemple, `findDOMNode(this)` trouve un nœud DOM qui appartient à un autre composant. Le composant `AutoselectingInput` fait le rendu de `MyInput`, qui est votre propre composant qui affiche un navigateur `<input>`.
+Dans l'exemple qui suit, `findDOMNode(this)` trouve un nœud DOM qui appartient à un autre composant. Le composant `AutoselectingInput` fait le rendu de `MyInput`, lequel est votre propre composant qui affiche un élément `<input>` natif.
 
 <Sandpack>
 
@@ -271,7 +271,7 @@ export default function App() {
   return (
     <>
       <button onClick={() => setShow(true)}>
-        Voir l'exemple
+        Voir l’exemple
       </button>
       <hr />
       {show && <AutoselectingInput />}
@@ -306,12 +306,12 @@ export default function MyInput() {
 
 </Sandpack>
 
-Notez que l'appel de `findDOMNode(this)` à l'intérieur de `AutoselectingInput` vous donne toujours le DOM `<input>` - même si le JSX de ce `<input>` est masqué à l'intérieur du composant `MyInput`. Cela semble pratique dans l'exemple ci-dessus, mais il conduit à un code fragile. Imaginez que vous voulez modifier `MyInput` plutard et l'enrober autour d'un `<div>`. Cela ne respectera pas le code de `AutoselectingInput` (qui attend de trouver un `<input>`).
+Notez que l'appel de `findDOMNode(this)` à l'intérieur de `AutoselectingInput` vous donne toujours le nœud DOM `<input>` — même si le JSX de ce `<input>` est masqué à l'intérieur du composant `MyInput`. Ça peut sembler pratique dans l'exemple ci-dessus, mais ce code est fragile. Imaginez que vous vouliez modifier `MyInput` plus tard et l'enrober dans une `<div>`. Ça fera planter le code de `AutoselectingInput` (qui s'attend à trouver un `<input>`).
 
-Pour remplacer `findDOMNode` dans cet exemple, les deux composants doivent être coordonnés :
+Pour remplacer `findDOMNode` dans cet exemple, les deux composants doivent se coordonner :
 
-1. `AutoSelectingInput` doit déclarer un ref, comme dans [l'exemple précédent](#reading-components-own-dom-node-from-a-ref), et le founir à `<MyInput>`.
-2. `MyInput` doit être déclaré avec [`forwardRef`](/reference/react/forwardRef) pour prendre ce ref et le transmettre au nœud `<input>`.
+1. `AutoSelectingInput` doit déclarer une ref, comme dans [l'exemple précédent](#reading-components-own-dom-node-from-a-ref), et la fournir à `<MyInput>`.
+2. `MyInput` doit être déclaré avec [`forwardRef`](/reference/react/forwardRef) pour prendre cette ref et la transmettre au nœud `<input>`.
 
 C'est ce que fait cette version, qui n'a donc plus besoin de `findDOMNode` :
 
@@ -326,7 +326,7 @@ export default function App() {
   return (
     <>
       <button onClick={() => setShow(true)}>
-        Afficher l'exemple
+        Afficher l’exemple
       </button>
       <hr />
       {show && <AutoselectingInput />}
@@ -369,7 +369,7 @@ export default MyInput;
 
 </Sandpack>
 
-Voici à quoi ressemblerait ce code avec les fonctions composants au lieu de classes :
+Voici à quoi ressemblerait ce code avec des fonctions composants au lieu de classes :
 
 <Sandpack>
 
@@ -382,7 +382,7 @@ export default function App() {
   return (
     <>
       <button onClick={() => setShow(true)}>
-        Afficher l'exemple
+        Afficher l’exemple
       </button>
       <hr />
       {show && <AutoselectingInput />}
@@ -421,16 +421,16 @@ export default MyInput;
 
 ---
 
-### Ajout d'un élement `<div>` enrobant {/*adding-a-wrapper-div-element*/}
+### Ajouter un élément `<div>` d'enrobage {/*adding-a-wrapper-div-element*/}
 
-Souvent un composant a besoin de connaître la position et la taille de ses enfants. Il est donc tentant de trouver l'enfant avec `findDOMNode(this)`, et utiliser la méthode du DOM comme [`getBoundingClientRect`](https://developer.mozilla.org/fr/docs/Web/API/Element/getBoundingClientRect) pour des mesures.
+Il arrive qu'un composant ait besoin de connaître la position et la taille de ses enfants. Il est donc tentant de trouver l'enfant avec `findDOMNode(this)`, puis d'utiliser des méthodes DOM telles que [`getBoundingClientRect`](https://developer.mozilla.org/fr/docs/Web/API/Element/getBoundingClientRect) pour faire des mesures.
 
-Il n'existe actuellement aucun équivalent direct pour ce cas d'utilisation, c'est pourquoi `findDOMNode` est déprécié mais n'a pas encore été retiré complètement de React. En attendant, vous pouvez essayez d'afficher un nœud `<div>` enrobant le contenu comme solution de contournement, et d'obtenir un ref à ce nœud. Cependant, les enveloppes supplémentaires peuvent nuire à la stylisation.
+Il n'existe actuellement aucun équivalent direct pour ce cas d'utilisation, c'est pourquoi `findDOMNode` est déprécié mais n'a pas encore été complètement retiré de React. En attendant, vous pouvez essayer d'enrober votre contenu avec un nœud `<div>` comme solution de contournement, puis d'obtenir une ref à ce nœud. Cependant, les enrobages supplémentaires peuvent nuire à l'application des styles.
 
 ```js
 <div ref={someRef}>
   {children}
 </div>
 ```
 
-Cela s'applique également à la focalisation et au défilement vers des enfants arbitraires.
+Ça s'applique également à la gestion du focus d'enfants quelconques, ou au défilement vers ces enfants.
