From 46bb302243cd3062a73b2a47c6a9c37cc3116ae7 Mon Sep 17 00:00:00 2001 From: Alessandro De Blasis Date: Mon, 14 Sep 2026 20:57:24 +0000 Subject: [PATCH 1/2] translate(reference): createRef (#682) (#714) Signed-off-by: Alessandro De Blasis --- src/content/reference/react/createRef.md | 47 ++++++++++++++---------- 1 file changed, 27 insertions(+), 20 deletions(-) diff --git a/src/content/reference/react/createRef.md b/src/content/reference/react/createRef.md index 2a3ba6aa3..68bc53aa3 100644 --- a/src/content/reference/react/createRef.md +++ b/src/content/reference/react/createRef.md @@ -1,16 +1,23 @@ --- title: createRef +translationStatus: ai-draft --- + + +Questa pagina è stata tradotta automaticamente e supervisionata da un maintainer. Un'ulteriore revisione da parte della community sarebbe comunque utile. [Migliora questa traduzione](https://github.com/reactjs/it.react.dev/edit/main/src/content/reference/react/createRef.md). + + + -`createRef` is mostly used for [class components.](/reference/react/Component) Function components typically rely on [`useRef`](/reference/react/useRef) instead. +`createRef` è usato soprattutto per i [componenti classe](/reference/react/Component). I componenti funzione di solito usano [`useRef`](/reference/react/useRef). -`createRef` creates a [ref](/learn/referencing-values-with-refs) object which can contain arbitrary value. +`createRef` crea un oggetto [ref](/learn/referencing-values-with-refs) che può contenere un valore arbitrario. ```js class MyInput extends Component { @@ -29,7 +36,7 @@ class MyInput extends Component { ### `createRef()` {/*createref*/} -Call `createRef` to declare a [ref](/learn/referencing-values-with-refs) inside a [class component.](/reference/react/Component) +Chiama `createRef` per dichiarare una [ref](/learn/referencing-values-with-refs) all'interno di un [componente classe](/reference/react/Component). ```js import { createRef, Component } from 'react'; @@ -40,31 +47,31 @@ class MyComponent extends Component { // ... ``` -[See more examples below.](#usage) +[Vedi altri esempi sotto.](#usage) #### Parameters {/*parameters*/} -`createRef` takes no parameters. +`createRef` non accetta parametri. #### Returns {/*returns*/} -`createRef` returns an object with a single property: +`createRef` restituisce un oggetto con una singola proprietà: -* `current`: Initially, it's set to the `null`. You can later set it to something else. If you pass the ref object to React as a `ref` attribute to a JSX node, React will set its `current` property. +* `current`: inizialmente è impostato su `null`. Puoi cambiarlo in seguito con un altro valore. Se passi l'oggetto ref a React come attributo `ref` su un nodo JSX, React imposterà la sua proprietà `current`. #### Caveats {/*caveats*/} -* `createRef` always returns a *different* object. It's equivalent to writing `{ current: null }` yourself. -* In a function component, you probably want [`useRef`](/reference/react/useRef) instead which always returns the same object. -* `const ref = useRef()` is equivalent to `const [ref, _] = useState(() => createRef(null))`. +* `createRef` restituisce sempre un oggetto *diverso*. Equivale a scrivere `{ current: null }` manualmente. +* In un componente funzione, probabilmente preferirai [`useRef`](/reference/react/useRef), che restituisce sempre lo stesso oggetto. +* `const ref = useRef()` equivale a `const [ref, _] = useState(() => createRef(null))`. --- ## Usage {/*usage*/} -### Declaring a ref in a class component {/*declaring-a-ref-in-a-class-component*/} +### Dichiarare una ref in un componente classe {/*declaring-a-ref-in-a-class-component*/} -To declare a ref inside a [class component,](/reference/react/Component) call `createRef` and assign its result to a class field: +Per dichiarare una ref all'interno di un [componente classe](/reference/react/Component), chiama `createRef` e assegna il risultato a un campo di classe: ```js {4} import { Component, createRef } from 'react'; @@ -76,7 +83,7 @@ class Form extends Component { } ``` -If you now pass `ref={this.inputRef}` to an `` in your JSX, React will populate `this.inputRef.current` with the input DOM node. For example, here is how you make a button that focuses the input: +Se passi `ref={this.inputRef}` a un `` nel tuo JSX, React popolerà `this.inputRef.current` con il nodo DOM dell'input. Ad esempio, ecco come creare un pulsante che mette a fuoco l'input: @@ -95,7 +102,7 @@ export default class Form extends Component { <> ); @@ -107,7 +114,7 @@ export default class Form extends Component { -`createRef` is mostly used for [class components.](/reference/react/Component) Function components typically rely on [`useRef`](/reference/react/useRef) instead. +`createRef` è usato soprattutto per i [componenti classe](/reference/react/Component). I componenti funzione di solito usano [`useRef`](/reference/react/useRef). @@ -115,9 +122,9 @@ export default class Form extends Component { ## Alternatives {/*alternatives*/} -### Migrating from a class with `createRef` to a function with `useRef` {/*migrating-from-a-class-with-createref-to-a-function-with-useref*/} +### Migrare da una classe con `createRef` a una funzione con `useRef` {/*migrating-from-a-class-with-createref-to-a-function-with-useref*/} -We recommend using function components instead of [class components](/reference/react/Component) in new code. If you have some existing class components using `createRef`, here is how you can convert them. This is the original code: +Nel codice nuovo consigliamo di usare componenti funzione al posto dei [componenti classe](/reference/react/Component). Se hai componenti classe esistenti che usano `createRef`, ecco come convertirli. Questo è il codice originale: @@ -136,7 +143,7 @@ export default class Form extends Component { <> ); @@ -146,7 +153,7 @@ export default class Form extends Component { -When you [convert this component from a class to a function,](/reference/react/Component#alternatives) replace calls to `createRef` with calls to [`useRef`:](/reference/react/useRef) +Quando [converti questo componente da classe a funzione](/reference/react/Component#alternatives), sostituisci le chiamate a `createRef` con chiamate a [`useRef`](/reference/react/useRef): @@ -164,7 +171,7 @@ export default function Form() { <> ); From 75999d6b5bc628810615004bbeb44e0f786b72da Mon Sep 17 00:00:00 2001 From: Alessandro De Blasis Date: Mon, 14 Sep 2026 23:57:34 +0300 Subject: [PATCH 2/2] translate(reference): isValidElement Signed-off-by: Alessandro De Blasis Co-authored-by: Cursor --- src/content/reference/react/isValidElement.md | 75 ++++++++++--------- 1 file changed, 41 insertions(+), 34 deletions(-) diff --git a/src/content/reference/react/isValidElement.md b/src/content/reference/react/isValidElement.md index bc4fbaef4..d4a1b90e7 100644 --- a/src/content/reference/react/isValidElement.md +++ b/src/content/reference/react/isValidElement.md @@ -1,10 +1,17 @@ --- title: isValidElement +translationStatus: ai-draft --- + + +Questa pagina è stata tradotta automaticamente e supervisionata da un maintainer. Un'ulteriore revisione da parte della community sarebbe comunque utile. [Migliora questa traduzione](https://github.com/reactjs/it.react.dev/edit/main/src/content/reference/react/isValidElement.md). + + + -`isValidElement` checks whether a value is a React element. +`isValidElement` ti permette di verificare se un valore è un elemento React. ```js const isElement = isValidElement(value) @@ -20,68 +27,68 @@ const isElement = isValidElement(value) ### `isValidElement(value)` {/*isvalidelement*/} -Call `isValidElement(value)` to check whether `value` is a React element. +Chiama `isValidElement(value)` per verificare se `value` è un elemento React. ```js import { isValidElement, createElement } from 'react'; -// ✅ React elements +// ✅ Elementi React console.log(isValidElement(

)); // true console.log(isValidElement(createElement('p'))); // true -// ❌ Not React elements +// ❌ Non sono elementi React console.log(isValidElement(25)); // false console.log(isValidElement('Hello')); // false console.log(isValidElement({ age: 42 })); // false ``` -[See more examples below.](#usage) +[Vedi altri esempi sotto.](#usage) #### Parameters {/*parameters*/} -* `value`: The `value` you want to check. It can be any a value of any type. +* `value`: Il valore che vuoi verificare. Può essere di qualsiasi tipo. #### Returns {/*returns*/} -`isValidElement` returns `true` if the `value` is a React element. Otherwise, it returns `false`. +`isValidElement` restituisce `true` se `value` è un elemento React. Altrimenti, restituisce `false`. #### Caveats {/*caveats*/} -* **Only [JSX tags](/learn/writing-markup-with-jsx) and objects returned by [`createElement`](/reference/react/createElement) are considered to be React elements.** For example, even though a number like `42` is a valid React *node* (and can be returned from a component), it is not a valid React element. Arrays and portals created with [`createPortal`](/reference/react-dom/createPortal) are also *not* considered to be React elements. +* **Solo i [tag JSX](/learn/writing-markup-with-jsx) e gli oggetti restituiti da [`createElement`](/reference/react/createElement) sono considerati elementi React.** Ad esempio, anche se un numero come `42` è un *nodo React* valido (e può essere restituito da un componente), non è un elemento React valido. Anche gli array e i [portali](/reference/react-dom/createPortal) creati con [`createPortal`](/reference/react-dom/createPortal) *non* sono considerati elementi React. --- ## Usage {/*usage*/} -### Checking if something is a React element {/*checking-if-something-is-a-react-element*/} +### Verificare se qualcosa è un elemento React {/*checking-if-something-is-a-react-element*/} -Call `isValidElement` to check if some value is a *React element.* +Chiama `isValidElement` per verificare se un valore è un *elemento React.* -React elements are: +Gli elementi React sono: -- Values produced by writing a [JSX tag](/learn/writing-markup-with-jsx) -- Values produced by calling [`createElement`](/reference/react/createElement) +- Valori prodotti scrivendo un [tag JSX](/learn/writing-markup-with-jsx) +- Valori prodotti chiamando [`createElement`](/reference/react/createElement) -For React elements, `isValidElement` returns `true`: +Per gli elementi React, `isValidElement` restituisce `true`: ```js import { isValidElement, createElement } from 'react'; -// ✅ JSX tags are React elements +// ✅ I tag JSX sono elementi React console.log(isValidElement(

)); // true console.log(isValidElement()); // true -// ✅ Values returned by createElement are React elements +// ✅ I valori restituiti da createElement sono elementi React console.log(isValidElement(createElement('p'))); // true console.log(isValidElement(createElement(MyComponent))); // true ``` -Any other values, such as strings, numbers, or arbitrary objects and arrays, are not React elements. +Qualsiasi altro valore, come stringhe, numeri o oggetti e array arbitrari, non è un elemento React. -For them, `isValidElement` returns `false`: +Per questi, `isValidElement` restituisce `false`: ```js -// ❌ These are *not* React elements +// ❌ Questi *non* sono elementi React console.log(isValidElement(null)); // false console.log(isValidElement(25)); // false console.log(isValidElement('Hello')); // false @@ -90,39 +97,39 @@ console.log(isValidElement([

,
])); // false console.log(isValidElement(MyComponent)); // false ``` -It is very uncommon to need `isValidElement`. It's mostly useful if you're calling another API that *only* accepts elements (like [`cloneElement`](/reference/react/cloneElement) does) and you want to avoid an error when your argument is not a React element. +È molto raro aver bisogno di `isValidElement`. È soprattutto utile se stai chiamando un'altra API che accetta *solo* elementi (come fa [`cloneElement`](/reference/react/cloneElement)) e vuoi evitare un errore quando il tuo argomento non è un elemento React. -Unless you have some very specific reason to add an `isValidElement` check, you probably don't need it. +A meno che tu non abbia un motivo molto specifico per aggiungere un controllo con `isValidElement`, probabilmente non ne hai bisogno. -#### React elements vs React nodes {/*react-elements-vs-react-nodes*/} +#### Elementi React vs nodi React {/*react-elements-vs-react-nodes*/} -When you write a component, you can return any kind of *React node* from it: +Quando scrivi un componente, puoi restituire qualsiasi tipo di *nodo React*: ```js function MyComponent() { - // ... you can return any React node ... + // ... puoi restituire qualsiasi nodo React ... } ``` -A React node can be: +Un nodo React può essere: -- A React element created like `
` or `createElement('div')` -- A portal created with [`createPortal`](/reference/react-dom/createPortal) -- A string -- A number -- `true`, `false`, `null`, or `undefined` (which are not displayed) -- An array of other React nodes +- Un elemento React creato come `
` o `createElement('div')` +- Un [portale](/reference/react-dom/createPortal) creato con [`createPortal`](/reference/react-dom/createPortal) +- Una stringa +- Un numero +- `true`, `false`, `null` o `undefined` (che non vengono visualizzati) +- Un array di altri nodi React -**Note `isValidElement` checks whether the argument is a *React element,* not whether it's a React node.** For example, `42` is not a valid React element. However, it is a perfectly valid React node: +**Nota `isValidElement` verifica se l'argomento è un *elemento React,* non se è un nodo React.** Ad esempio, `42` non è un elemento React valido. Tuttavia, è un nodo React perfettamente valido: ```js function MyComponent() { - return 42; // It's ok to return a number from component + return 42; // Va bene restituire un numero da un componente } ``` -This is why you shouldn't use `isValidElement` as a way to check whether something can be rendered. +Per questo non dovresti usare `isValidElement` per verificare se qualcosa può essere renderizzato.