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
A single-page application is an application that loads a single HTML page and all the necessary assets (such as JavaScript and CSS) required for the application to run. Any interactions with the page or subsequent pages do not require a round trip to the server which means the page is not reloaded.
12
+
Un'applicazione single-page è un'applicazione che carica una singola pagina HTML e tutte le risorse necessarie (quali Javascript e CSS) per consentirne l'esecuzione. Qualunque interazione con la pagina o con le pagine successive non richiede un'interrogazione al server il che significa che la pagina non viene ricaricata.
13
13
14
-
Though you may build a single-page application in React, it is not a requirement. React can also be used for enhancing small parts of existing websites with additional interactivity. Code written in React can coexist peacefully with markup rendered on the server by something like PHP, or with other client-side libraries. In fact, this is exactly how React is being used at Facebook.
14
+
Sebbene tu possa creare applicazioni single-page in React, questo non rappresenta un requisito. React può anche essere usato per migliorare piccole parti di un sito già esistente aggiungendo ulteriore interattività. Il codice scritto in React può coesistere tranquillamente con un markup renderizzato dal server tramite qualcosa di simile a PHP, o con altre librerie lato client. Infatti, questo è esattamente il modo in cui React viene utilizzato in Facebook.
These acronyms all refer to the most recent versions of the ECMAScript Language Specification standard, which the JavaScript language is an implementation of. The ES6 version (also known as ES2015) includes many additions to the previous versions such as: arrow functions, classes, template literals, `let`and`const` statements. You can learn more about specific versions [here](https://en.wikipedia.org/wiki/ECMAScript#Versions).
18
+
Tutti questi acronimi si riferiscono alle versioni più recenti dello standard ECMAScript Language Specification, di cui il linguaggio JavaScript è un'implementazione. La versione ES6 (nota anche come ES2015) include molte aggiunte rispetto alle versioni precedenti, ad esempio: arrow functions, classi, stringhe template, istruzioni `let`e`const`. Puoi scoprire di più riguardo le versioni specifiche [qui](https://en.wikipedia.org/wiki/ECMAScript#Versions).
19
19
20
-
## Compilers {#compilers}
20
+
## Compilatori {#compilers}
21
21
22
-
A JavaScript compiler takes JavaScript code, transforms it and returns JavaScript code in a different format. The most common use case is to take ES6 syntax and transform it into syntax that older browsers are capable of interpreting. [Babel](https://babeljs.io/)is the compiler most commonly used with React.
22
+
Un compilatore JavaScript prende il codice JavaScript, lo trasforma e ritorna codice JavaScript in un formato differente. Il caso d'uso più comune è quello di prendere un codice con sintassi ES6 e trasformarlo in uno con sintassi che può essere interpretata da browser più vecchi. [Babel](https://babeljs.io/)è il compilatore più comunemente usato con React.
23
23
24
24
## Bundlers {#bundlers}
25
25
26
-
Bundlers take JavaScript and CSS code written as separate modules (often hundreds of them), and combine them together into a few files better optimized for the browsers. Some bundlers commonly used in React applications include [Webpack](https://webpack.js.org/)and[Browserify](http://browserify.org/).
26
+
I bundlers prendono codice JavaScript e CSS scritto in moduli separati (spesso sono centinaia) e li raggruppa in alcuni file meglio ottimizzati per i browser. Tra i bundler più comunemente usati nelle applicazioni React troviamo [Webpack](https://webpack.js.org/)e[Browserify](http://browserify.org/).
27
27
28
-
## Package Managers {#package-managers}
28
+
## Gestori dei pacchetti {#package-managers}
29
29
30
-
Package managers are tools that allow you to manage dependencies in your project. [npm](https://www.npmjs.com/)and[Yarn](https://yarnpkg.com/)are two package managers commonly used in React applications. Both of them are clients for the same npm package registry.
30
+
I gestori dei pacchetti sono strumenti che ti consentono di gestire le dipendenze nel tuo progetto. [npm](https://www.npmjs.com/)e[Yarn](https://yarnpkg.com/)sono i due gestori dei pacchetti solitamente usati nelle applicazioni React. Entrambi sono client verso lo stesso registro dei pacchetti di npm.
31
31
32
32
## CDN {#cdn}
33
33
34
-
CDN stands for Content Delivery Network. CDNs deliver cached, static content from a network of servers across the globe.
34
+
CDN sta per Content Delivery Network. Le CDN consegnano contenuto statico e in cache da una rete di server sparsi nel globo.
35
35
36
36
## JSX {#jsx}
37
37
38
-
JSX is a syntax extension to JavaScript. It is similar to a template language, but it has full power of JavaScript. JSX gets compiled to `React.createElement()`calls which return plain JavaScript objects called "React elements". To get a basic introduction to JSX [see the docs here](/docs/introducing-jsx.html)and find a more in-depth tutorial on JSX [here](/docs/jsx-in-depth.html).
38
+
JSX è un'estensione sintattica di JavaScript. E' simile ad un linguaggio template, ma possiede tutta la potenza di JavaScript. JSX viene compilato in chiamate a `React.createElement()`che ritornano oggetti JavaScript chiamati "elementi React". Per un'introduzione base a JSX [puoi leggere qui la documentazione](/docs/introducing-jsx.html)e trovare un tutorial più dettagliato su JSX [qui](/docs/jsx-in-depth.html).
39
39
40
-
React DOM uses camelCase property naming convention instead of HTML attribute names. For example, `tabindex`becomes`tabIndex` in JSX. The attribute`class`is also written as `className`since `class`is a reserved word in JavaScript:
40
+
Il DOM di React usa la convenzione camelCase sui nomi delle proprietà invece dei nomi degli attributi HTML. Per esempio, `tabindex`diventa`tabIndex` in JSX. Anche l'attributo`class`viene scritto come `className`dal momento che `class`è una parola riservata in JavaScript:
React elements are the building blocks of React applications. One might confuse elements with a more widely known concept of "components". An element describes what you want to see on the screen. React elements are immutable.
52
+
Gli elementi React sono gli elementi costituenti delle applicazioni React. Si potrebbe confondere il concetto di elementi con quello maggiormente conosciuto di "componenti". Un elemento descrive quello che vuoi vedere sullo schermo. Gli elementi React sono immutabili.
53
53
54
54
```js
55
55
constelement=<h1>Hello, world</h1>;
56
56
```
57
57
58
-
Typically, elements are not used directly, but get returned from components.
58
+
Tipicamente, gli elementi non sono usati direttamente, ma ritornati dai componenti.
React components are small, reusable pieces of code that return a React element to be rendered to the page. The simplest version of React component is a plain JavaScript function that returns a React element:
62
+
I componenti React sono pezzi di codice piccoli e riusabili che ritornano un elemento React da renderizzare in pagina. La versione più semplice di un componente React è una funzione JavaScript che ritorna un elemento React:
63
63
64
64
```js
65
65
functionWelcome(props) {
66
66
return<h1>Hello, {props.name}</h1>;
67
67
}
68
68
```
69
69
70
-
Components can also be ES6 classes:
70
+
I componenti possono essere anche classi ES6:
71
71
72
72
```js
73
73
classWelcomeextendsReact.Component {
@@ -77,38 +77,38 @@ class Welcome extends React.Component {
77
77
}
78
78
```
79
79
80
-
Components can be broken down into distinct pieces of functionality and used within other components. Components can return other components, arrays, strings and numbers. A good rule of thumb is that if a part of your UI is used several times (Button, Panel, Avatar), or is complex enough on its own (App, FeedStory, Comment), it is a good candidate to be a reusable component. Component names should also always start with a capital letter (`<Wrapper/>`**not**`<wrapper/>`). See [this documentation](/docs/components-and-props.html#rendering-a-component)for more information on rendering components.
80
+
I componenti possono essere suddivisi in pezzi distinti di funzionalità e usati all'interno di altri componenti. I componenti possono ritornare altri componenti, array, stringhe e numeri. Una buona norma da seguire è che se una parte della tua UI viene usata diverse volte (Button, Panel, Avatar), o è di per sé sufficientemente complessa (App, FeedStory, Comment), allora risulterà un buon candidato per diventare un componente riusabile. I nomi dei componenti inoltre dovrebbero sempre partire con una lettera maiuscola (`<Wrapper/>`**e non**`<wrapper/>`). Vedi [questa documentazione](/docs/components-and-props.html#rendering-a-component)per maggiori informazioni sulla renderizzazione dei componenti.
A component needs `state`when some data associated with it changes over time. For example, a `Checkbox`component might need `isChecked`in its state, and a `NewsFeed`component might want to keep track of `fetchedPosts`in its state.
123
+
Un componente ha bisogno dello `state`quando alcuni dati associati con esso cambiano nel tempo. Per esempio, un componente `Checkbox`potrebbe aver bisogno di `isChecked`nel suo state, e un componente `NewsFeed`potrebbe voler tener traccia dei `fetchedPosts`nel suo state.
124
124
125
-
The most important difference between`state`and`props`is that `props`are passed from a parent component, but `state`is managed by the component itself. A component cannot change its `props`, but it can change its`state`.
125
+
La differenza più importante tra`state`e`props`è che le `props`sono passate da un componente padre, ma lo `state`viene gestito dal componente stesso. Un componente non può cambiare le sue `props`, ma può cambiare il suo`state`.
126
126
127
-
For each particular piece of changing data, there should be just one component that "owns" it in its state. Don't try to synchronize states of two different components. Instead, [lift it up](/docs/lifting-state-up.html)to their closest shared ancestor, and pass it down as props to both of them.
127
+
Per ogni pezzo di dato che cambia, ci dovrebbe essere solo un componente che "possiede" tale dato nel suo state. Non provare a sincronizzare lo state di due componenti diversi. Invece, [sollevalo](/docs/lifting-state-up.html)verso l'antenato comune più vicino, e passalo come props ad entrambi.
Lifecycle methods are custom functionality that gets executed during the different phases of a component. There are methods available when the component gets created and inserted into the DOM ([mounting](/docs/react-component.html#mounting)), when the component updates, and when the component gets unmounted or removed from the DOM.
131
+
I metodi del lifecycle sono funzionalità personalizzate che vengono eseguite durante le diverse fasi di un componente. Ci sono metodi disponibili quando il componente viene creato e inserito nel DOM ([montaggio](/docs/react-component.html#mounting)), quando il componente si aggiorna, e quando il componente viene smontato o rimosso dal DOM.
132
132
133
-
## [Controlled](/docs/forms.html#controlled-components) vs. [Uncontrolled Components](/docs/uncontrolled-components.html)
133
+
## [Componenti controllati](/docs/forms.html#controlled-components) vs. [Componenti non controllati](/docs/uncontrolled-components.html)
134
134
135
-
React has two different approaches to dealing with form inputs.
135
+
React ha due diversi approcci nel trattare gli input di un form.
136
136
137
-
An input form element whose value is controlled by React is called a *controlled component*. When a user enters data into a controlled component a change event handler is triggered and your code decides whether the input is valid (by re-rendering with the updated value). If you do not re-render then the form element will remain unchanged.
137
+
Un elemento input di un form il cui valore è controllato da React viene chiamato *componente controllato*. Quando un utente inserisce dati all'interno di un componente controllato viene lanciato un gestore dell'evento change e il tuo codice deciderà se l'input è valido (ri-renderizzando con il valore aggiornato). Se non ri-renderizzi allora l'elemento del form rimarrà immutato.
138
138
139
-
An *uncontrolled component* works like form elements do outside of React. When a user inputs data into a form field (an input box, dropdown, etc) the updated information is reflected without React needing to do anything. However, this also means that you can't force the field to have a certain value.
139
+
Un *componente non controllato* funziona allo stesso modo degli elementi del form al di fuori di React. Quando un utente inserisce dati in un campo del form (una casella di input, una lista a cascata, ecc.) le informazioni aggiornate trovano riscontro senza che React abbia bisogno di fare nulla. Tuttavia, questo significa anche che non puoi forzare un campo ad avere un certo valore.
140
140
141
-
In most cases you should use controlled components.
141
+
Nella maggior parte dei casi dovresti usare componenti controllati.
142
142
143
-
## [Keys](/docs/lists-and-keys.html) {#keys}
143
+
## [Chiavi](/docs/lists-and-keys.html) {#keys}
144
144
145
-
A "key" is a special string attribute you need to include when creating arrays of elements. Keys help React identify which items have changed, are added, or are removed. Keys should be given to the elements inside an array to give the elements a stable identity.
145
+
Una "chiave" è un attributo stringa speciale che hai bisogno di includere quando crei array di elementi. Le chiavi aiutano React ad identificare quali elementi sono cambiati, quali sono stati aggiunti, o quali sono stati rimossi. Le chiavi dovrebbero essere assegnate agli elementi all'interno di un array per dargli un'identità stabile.
146
146
147
-
Keys only need to be unique among sibling elements in the same array. They don't need to be unique across the whole application or even a single component.
147
+
Le chiavi necessitano solo di essere univoche tra gli elementi dello stesso array. Non c'è bisogno che siano univoche nell'intera applicazione o in un singolo componente.
148
148
149
-
Don't pass something like`Math.random()`to keys. It is important that keys have a "stable identity" across re-renders so that React can determine when items are added, removed, or re-ordered. Ideally, keys should correspond to unique and stable identifiers coming from your data, such as`post.id`.
149
+
Non passare cose come`Math.random()`alle chiavi. E' importante che le chiavi abbiano "un'identità stabile" tra le ri-renderizzazioni cosicché React possa determinare quali elementi sono stati aggiunti, rimossi, o riordinati. Idealmente, le chiavi dovrebbero corrispondere a identificatori stabili e univoci provenienti dai tuoi dati, come`post.id`.
150
150
151
151
## [Refs](/docs/refs-and-the-dom.html) {#refs}
152
152
153
-
React supports a special attribute that you can attach to any component. The`ref`attribute can be an object created by [`React.createRef()` function](/docs/react-api.html#reactcreateref)or a callback function, or a string (in legacy API). When the`ref`attribute is a callback function, the function receives the underlying DOM element or class instance (depending on the type of element) as its argument. This allows you to have direct access to the DOM element or component instance.
153
+
React supporta un attributo speciale che puoi attaccare ad ogni componente. L'attributo`ref`può essere un oggetto creato dalla [funzione `React.createRef()`](/docs/react-api.html#reactcreateref)o una funzione di callback, o una stringa (nelle API legacy). Quando l'attributo`ref`è una funzione di callback, la funzione riceve l'elemento DOM sottostante o l'istanza di classe come argomento (a seconda del tipo di elemento). Questo ti consente di avere accesso diretto all'elemento del DOM o all'istanza del componente.
154
154
155
-
Use refs sparingly. If you find yourself often using refs to "make things happen" in your app, consider getting more familiar with [top-down data flow](/docs/lifting-state-up.html).
155
+
Usa i refs con parsimonia. Se ti ritrovi a usare spesso i refs per "far funzionare le cose" nella tua app, comincia a prendere familiarità con il [flusso di dati top-down](/docs/lifting-state-up.html).
156
156
157
-
## [Events](/docs/handling-events.html) {#events}
157
+
## [Eventi](/docs/handling-events.html) {#events}
158
158
159
-
Handling events with React elements has some syntactic differences:
159
+
La gestione degli eventi con gli elementi React ha alcune differenze sintattiche:
160
160
161
-
*React event handlers are named using camelCase, rather than lowercase.
162
-
*With JSX you pass a function as the event handler, rather than a string.
161
+
*I gestori degli eventi React sono dichiarati in camelCase, piuttosto che in minuscolo.
162
+
*Con JSX puoi passare una funzione come gestore degli eventi, piuttosto che una stringa.
When a component's props or state change, React decides whether an actual DOM update is necessary by comparing the newly returned element with the previously rendered one. When they are not equal, React will update the DOM. This process is called "reconciliation".
166
+
Quando una prop o lo stato di un componente cambia, React decide se è necessario effettuare un aggiornamento del DOM confrontando il nuovo elemento ritornato con quello precedentemente renderizzato. Quando non sono uguali, React aggiornerà il DOM. Questo processo viene chiamato "riconciliazione".
0 commit comments